zoukankan      html  css  js  c++  java

  • python之路-Django

    安装

    1.pip3 install django

    2.到官网下载安装包

    执行：python3 setup.py install

    3.windows上添加环境变量

    在pyth中加入C:Python35Scripts（如果不添加，执行时就必须相应的文件夹下执行djingo-admin.exe）

    基本操作

    命令：

    1.创建project

    djingo-admin startproject mysite(项目的名字)创建目录

    创建的mysite目录

    mysite

    　　-mysite 内部都是些配置文件

    　　-manage.py 管理当前project

    2.运行

    传递

    cd mysite

    python3 manage.py runserver 127.0.0.1:8000

    在浏览器上输入127.0.0.1:8000

    3.创建app（app相当于一个项目中的各个模块，app处理业务逻辑）

    例子：

    project 运维平台

    　　配置文件

    　　管理文件

    　　app-01 资产管理

    　　app-02 监控

    　　......

    通过manage.py创建app

    cd mysite

    python manage.py startapp cmdb(名字)

    创建完成后，进入到cmdb中就可以看到很多.py文件

    其中migrations文件、modles.py（创建数据库，操作数据库）是操作数据库的

    admin.pyh后台管理，配置的djingo自带的后台

    apps.py 当前app的配置

    tests.py 单元测试

    views.py 业务处理

    pycharm

    新建project

    pycharm会自动执行djingo-admin startproject mysite

    创建app，点击pycharm的termial，执行python manage.py startapp cmdb(名字)

    运行：python3 manage.py runserver 127.0.0.1:8000（terminal终端）或者点击pycharm中的绿色箭头

    如果想编辑地址或者端口，点击箭头左边的project的名字，点击edit configrations

    配置文件

    数据库:jingo自带的数据库(sqlite)

    如果想换成mysql,可以做如下修改

    settings

     1 DATABASES = {
 2 
 3     'default': {
 4 
 5     'ENGINE': 'django.db.backends.mysql',
 6 
 7     'NAME':'dbname',
 8 
 9     'USER': 'root',
10 
11     'PASSWORD': 'xxx',
12 
13     'HOST': '',
14 
15     'PORT': '',
16 
17     }
18 
19 }
    数据库的更改

    由于Django内部连接MySQL时使用的是MySQLdb模块，而python3中还无此模块，所以需要使用pymysql来代替

    如下设置放置的与project同名的配置的 __init__.py文件中

    import pymysql

    pymysql.install_as_MySQLdb()

    模版

    1 TEMPLATE_DIRS = (
2 
3         os.path.join(BASE_DIR,'templates'),
4 
5     )
    模板

    静态文件

    1 STATICFILES_DIRS = (
2 
3         os.path.join(BASE_DIR,'static'),
4 
5     )
    静态文件

    数据库的创建

    在models.py中创建数据库

     创建类------》相当于表

    类中的字段----》相当于表中的列

    1 class UserInfo(models.Model):
2     nid = models.AutoField(primary_key=True)
3     username = models.CharField(max_length=32)
4     pwd = models.CharField(max_length=64)
5     age = models.IntegerField()
    表的创建

    写完后，要执行命令创建
    在终端执行 cd /mysite

    根据app的models.py生成数据库表
            python manage.py makemigrations
            python manage.py migrate

    注意：要在settings注册app名字(通过app注册，控制都让那些app生成数据库表)

     

    完成功能

    建立的项目中会有几个文件

    settings.py整体的配置文件

    urls.py 网页的对应关系

    wsgi.py djingo是基于wsgi开发的

    例子：

    urlpatterns = [ url(r'^admin/', admin.site.urls), 后面的admin.site.urls是一个函数，负责处理业务的，当url中匹配到前面的关键词后，这个函数开始处理请求。]

    这个是djingo自带的后台管理，在url中加127.0.0.1:8001/admin

    一般会把处理业务的函数放在app的views.py中

    这里就需要先把app中的views导入到urls这个文件中

    from cmdb import views

    创建一个对应关系

    urlpatterns = [
    # url(r'^admin/', admin.site.urls),
    url(r'^index/',views.index),         路由映射
    ]

    在views中创建一个函数（标红为重要信息）


    from django.shortcuts import render
    from django.shortcuts import HttpResponse

    # Create your views here.
    def index(requst):
    return HttpResponse('OK')

    这个函数至少包含一个参数request，request封装了用户请求相关信息。，return后面返回的可以是一个网页，也可以去一个html文件中拿到，

    如果想返回的是网页，就必须是return render（request，'index.html'）,此时我们要告诉jingo网页的位置，去settings设置，找到TEMPLATES，

    有个 'DIRS': [os.path.join(BASE_DIR, 'templates')]，BASE_DIR就是创建项目的目录位置，下面有个templates目录，只要把html文件放到这里就可以了。

    如果此时目录下面有个index.html就会找到了。

    提交登陆页面

    在同样的位置创建url路由映射，创建登陆网页，写登陆函数

    1 urlpatterns = [
2     # url(r'^admin/', admin.site.urls),
3     url(r'^index/',views.index),
4     url(r'^login/', views.login),
5 ]
    登陆映射
    1 def login(request):
2     return render(request,'login.html')
    登陆函数

    登陆函数自己写

    注意：我们提交网页的方式是以post方式提交的，此时，需要我们到settings中将MIDDLEWARE下的'django.middleware.csrf.CsrfViewMiddleware'注释掉，否则无法提交。

    接下来，我们就要对用户提交的数据进行验证

    需要对登陆函数进行完善（render里写的是模版，redirect写的是url）

     1 from django.shortcuts import render
 2 from django.shortcuts import HttpResponse
 3 from django.shortcuts import redirect
 4 
 5 # Create your views here.
 6 def index(request):
 7     # return HttpResponse('OK')
 8     return render(request,'index.html')
 9 def login(request):
10     #request.method  "GET" "POST" 用户已什么方式提交，就以什么方式获取
11     if request.method == 'GET':
12         return render(request,'login.html')
13     elif request.method == 'POST':
14         #获取用户提交的数据（以字典的防护死提交）
15         username = request.POST.get('user')     #此处用get获取而不用 request.POST[user]是防止没有找到数据是报错
16         password = request.POST.get('pwd')
17         if username == 'root' and password == '111111':
18             # return redirect('http://www.baidu.com')
19             return redirect('/index/')  #这里写的相当于路径，在127.0.0.1：8001/index/
20         else:
21             return render(request,'login.html')
    登陆函数

    实现数据的读取，以及添加

     1.读取html文件内容

            将特殊的标记和{'data':DB}进行渲染，得到一个字符串

     2.将html内容返回给用户

     1 from django.shortcuts import render
 2 from django.shortcuts import HttpResponse
 3 from django.shortcuts import redirect
 4 DB = [
 5     {'hostname':'c1.com','port':80},
 6     {'hostname':'c2.com','port': 81},
 7     {'hostname':'c3.com','port': 82},
 8     {'hostname':'c4.com','port': 83},
 9 ]
10 # Create your views here.
11 def index(request):
12     # return HttpResponse('OK')
13     if request.method == 'GET':
14         #用户获取数据 pymysql
15         #模版渲染
16         return render(request,'index.html',{'data':DB})
17     """
18     1.读取html文件内容
19         将特殊的标记和{'data':DB}进行渲染，得到一个字符串
20     2.将html内容返回给用户
21     """
22     if request.method == 'POST':
23         host = request.POST.get('host')
24         port = request.POST.get('port')
25         temp = {'hostname':host,'port':port}
26         DB.append(temp)
27         return render(request, 'index.html', {'data': DB}) #再次渲染即可
28 def login(request):
29     #request.method  "GET" "POST" 用户已什么方式提交，就以什么方式获取
30     if request.method == 'GET':
31         #用户获取数据 pymysql
32         #模版渲染
33         return render(request,'index.html',{'data':DB})
34         return render(request,'login.html')
35     elif request.method == 'POST':
36         #获取用户提交的数据（以字典的防护死提交）
37         username = request.POST.get('user')     #此处用get获取而不用 request.POST[user]是防止没有找到数据是报错
38         password = request.POST.get('pwd')
39         if username == 'root' and password == '111111':
40             # return redirect('http://www.baidu.com')
41             return redirect('/index/')  #这里写的相当于路径，在127.0.0.1：8001/index/
42         else:
43             return render(request,'login.html')
    Views的配置
     1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5         <title>Title</title>
 6     </head>
 7     <body>
 8         <h1>欢迎登陆</h1>
 9         <h3>添加内容</h3>
10         <form action="/index/" method="POST">
11             <input type="text" placeholder="主机名" name="host" />
12             <input type="text" placeholder="端口" name="port" />
13             <input type="submit" value="增加" />
14         </form>
15         <h3>资产列表</h3>
16         <table border="1">
17             <thead>
18                 <tr>
19                     <th>主机名</th>
20                     <th>端口</th>
21                 </tr>
22             </thead>
23             <tbody>
24                 {% for row in data %}
25                     <tr>
26                     <td>{{row.hostname}}</td>
27                     <td>{{row.port}}</td>
28                     </tr>
29                 {% endfor %}
30             </tbody>
31         </table>
32     </body>
33 </html>
    index的配置

    静态文件的设置

    1.要在project的目录下建立一个静态文件，和app目录在同一界别

    2.在网页加入文件链接

    3. 接下来就要告诉jingo文件的位置，在settings中最下面添加

    STATICFILES_DIRS = (

        os.path.join(BASE_DIR,'static'),

    )

    这个是元组，必须要有逗号

    创建表

    在项目中的models中操作

     1 from __future__ import unicode_literals
 2 
 3 from django.db import models
 4 
 5 # Create your models here.
 6 class UserInfo(models.Model):
 7     nid = models.AutoField(primary_key=True)
 8     username = models.CharField(max_length=32)
 9     pwd = models.CharField(max_length=64)
10     age = models.IntegerField()
    创建表

    执行命令，生成表

    python manage.py makemigrations
    python manage.py migrate

    创建完数据库后提取数据

    models.tb.objects.all()
    models.tb.objects.filter(nid=1)
    models.tb.objects.filter(nid=1).first()

    也可以将filter换为get，但是get只适用于单个数据，如果有多个查询结果，就会报错

    只想查看表中个别字段中的内容：

    models.Book.objects.values('name','price')

    models.Book.objects.exclude(name='py')反查询

    1 def users(request):
2     users_list = models.UserInfo.objects.all()
3     return render(request,'users.html',{'data':users_list})
    views
     1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8     <h1>用户列表</h1>
 9     <ul>
10         {% for row in data %}      #这里循环的东西一定是字典的key
11         <li>
12         {{ row.nid}} - {{ row.username }} -
13         {{ row.pwd }}- {{ row.age }} -
14         </li>
15         {% endfor %}
16     </ul>
17 </body>
18 </html>
    users.html

    数据的增加

     models.tb.objects.create(...)
                
    obj = models.tb(...)
    obj.save()

     1 from django.shortcuts import render
 2 from django.shortcuts import HttpResponse
 3 from A1 import models
 4 from django.shortcuts import redirect
 5 # Create your views here.
 6 def users(request):
 7     users_list = models.UserInfo.objects.all()
 8     return render(request,'users.html',{'data':users_list})
 9 def add_user(request):
10     if request.method == 'GET':
11         return render(request,'add_user.html ')
12     elif request.method == 'POST':
13         u = request.POST.get('user')
14         p = request.POST.get('pwd')
15         a = request.POST.get('age')
16         # obj = models.UserInfo(username=u,pwd=p,age=a)
17         # obj.save()
18         models.UserInfo.objects.create(username=u,pwd=p,age=a)
19         return redirect('/users')
    views
     1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8     <form method="POST" action="/add_user">
 9         <input type="text" name="user" placeholder="用户名" />
10         <input type="text" name="pwd" placeholder="密码" />
11         <input type="text" name="age" placeholder="年龄" />
12         <input type="submit" value="提交">
13 
14     </form>
15 </body>
16 </html>
    add_users.html
    urls
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^users', views.users),
    url(r'^add_user',views.add_user),
]
    urls

    添加按钮，需要跳转，通过a标签的href，href='/add_user'

     1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8     <h1>用户列表</h1>
 9     <a href="/add_user">添加</a>
10     <ul>
11         {% for row in data %}
12         <li>
13         {{ row.nid}} - {{ row.username }} -
14         {{ row.pwd }}- {{ row.age }} -
15         </li>
16         {% endfor %}
17     </ul>
18 </body>
19 </html>
    添加按钮

    数据的删除

     models.tb.objects.all().delete()
     models.tb.objects.filter(nid=1).delete()

     1 views
 2 from django.shortcuts import render
 3 from django.shortcuts import HttpResponse
 4 from A1 import models
 5 from django.shortcuts import redirect
 6 # Create your views here.
 7 def users(request):
 8     users_list = models.UserInfo.objects.all()
 9     return render(request,'users.html',{'data':users_list})
10 def add_user(request):
11     if request.method == 'GET':
12         return render(request,'add_user.html ')
13     elif request.method == 'POST':
14         u = request.POST.get('user')
15         p = request.POST.get('pwd')
16         a = request.POST.get('age')
17         # obj = models.UserInfo(username=u,pwd=p,age=a)
18         # obj.save()
19         models.UserInfo.objects.create(username=u,pwd=p,age=a)
20         return redirect('/users')
21 def delete_user(request):
22     nnid = request.GET.get('nid')
23     models.UserInfo.objects.filter(nid=nnid).delete()      但凡遇到fileter、all时，获取的是列表
    views
    1 urlpatterns = [
2     url(r'^admin/', admin.site.urls),
3     url(r'^users', views.users),
4     url(r'^add_user', views.add_user),
5     url(r'^delete_user',views.delete_user),
6 ]
    urls
     1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8     <h1>用户列表</h1>
 9     <a href="/add_user">添加</a>
10     <ul>
11         {% for row in data %}
12         <li>
13         {{ row.nid}} - {{ row.username }} -
14         {{ row.pwd }}- {{ row.age }} -
15             <a href="/delete_user?nid={{ row.nid }}">删除</a>   #此处书写类似于网页地址形式，以get形式传值
16         </li>
17         {% endfor %}
18     </ul>
19 </body>
20 </html>
    添加删除按钮

    数据的修改

    models.tb.objects.all().update(...)
    models.tb.objects.filter(nid=1).update(...)

    1 urlpatterns = [
2     url(r'^admin/', admin.site.urls),
3     url(r'^users', views.users),
4     url(r'^add_user', views.add_user),
5     url(r'^delete_user',views.delete_user),
6     url(r'^edit_user',views.edit_user),
7 ]
    urls
     1 from django.shortcuts import render
 2 from django.shortcuts import HttpResponse
 3 from A1 import models
 4 from django.shortcuts import redirect
 5 # Create your views here.
 6 def users(request):
 7     users_list = models.UserInfo.objects.all()
 8     return render(request,'users.html',{'data':users_list})
 9 def add_user(request):
10     if request.method == 'GET':
11         return render(request,'add_user.html ')
12     elif request.method == 'POST':
13         u = request.POST.get('user')
14         p = request.POST.get('pwd')
15         a = request.POST.get('age')
16         # obj = models.UserInfo(username=u,pwd=p,age=a)
17         # obj.save()
18         models.UserInfo.objects.create(username=u,pwd=p,age=a)
19         return redirect('/users')
20 def delete_user(request):
21     nnid = request.GET.get('nid')
22     models.UserInfo.objects.filter(nid=nnid).delete()
23     return redirect('/users')
24 def edit_user(request):
25     if request.method == 'GET':
26         nnid = request.GET.get('nid')
27         v = models.UserInfo.objects.filter(nid=nnid).first()    #首先通过nid获取，所有的值，然后通过render将之给html，并进行渲染
28         return render(request,'edit_user.html',{'obj':v})
29     elif request.method == 'POST':                              #将提交的数据提取，并到数据库更新
30         nnid = request.POST.get('nid')
31         u = request.POST.get('user')
32         p = request.POST.get('pwd')
33         a = request.POST.get('age')
34         models.UserInfo.objects.filter(nid=nnid).update(username=u,pwd=p,age=a)
35         return redirect('/users')
    views
     1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8     <form action="/edit_user" method="POST">
 9         <p style="display: none"><input type="text" name="nid" value="{{ obj.nid }}"></p>     #通过values将值默认添加到文本框汇总。我们要通过nid更新至，但是不能让用户看到
10         <input type="text" name="user" placeholder="用户名" value="{{ obj.username }}" />
11         <input type="text" name="pwd" placeholder="密码" value="{{ obj.pwd }}" />
12         <input type="text" name="age" placeholder="年龄" value="{{ obj.age}}" />
13         <input type="submit" value="提交">
14 
15     </form>
16 
17 </body>
18 </html>
    edit_user.html
     1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8     <h1>用户列表</h1>
 9     <a href="/add_user">添加</a>
10     <ul>
11         {% for row in data %}
12         <li>
13         {{ row.nid}} - {{ row.username }} -
14         {{ row.pwd }}- {{ row.age }} -
15             <a href="/delete_user?nid={{ row.nid }}">删除</a> -
16             <a href="edit_user?nid={{ row.nid }}">编辑</a>
17         </li>
18         {% endfor %}
19     </ul>
20 </body>
21 </html>
    添加编辑按钮

    写urls时，通过正则表达式来实现动态的路由系统

    1.^users$,来精确匹配

    2.users.html 来匹配，伪造成静态页面
    3. url(r'^edit_user_new-(?P<nnid>d+).html$', views.edit_user_new)

    1 urlpatterns = [
2     url(r'^admin/', admin.site.urls),
3     url(r'^users$', views.users),
4     url(r'^add_user$', views.add_user),
5     url(r'^delete_user$',views.delete_user),
6     url(r'^edit_user$',views.edit_user),
7     url(r'^edit_user_new-(?P<nnid>d+).html$',views.edit_user_new),
8 ]
    urls

    注意：如果r'^add_user$'如果add_user首尾不加控制，那么r'^edit_user_new-(?P<nnid>d+).html$就永远执行不了，如果不加，
    只要匹配到add_user就会执行第一个

     1 from django.shortcuts import render
 2 from django.shortcuts import HttpResponse
 3 from A1 import models
 4 from django.shortcuts import redirect
 5 # Create your views here.
 6 def users(request):
 7     users_list = models.UserInfo.objects.all()
 8     return render(request,'users.html',{'data':users_list})
 9 def add_user(request):
10     if request.method == 'GET':
11         return render(request,'add_user.html ')
12     elif request.method == 'POST':
13         u = request.POST.get('user')
14         p = request.POST.get('pwd')
15         a = request.POST.get('age')
16         # obj = models.UserInfo(username=u,pwd=p,age=a)
17         # obj.save()
18         models.UserInfo.objects.create(username=u,pwd=p,age=a)
19         return redirect('/users')
20 def delete_user(request):
21     nnid = request.GET.get('nid')
22     models.UserInfo.objects.filter(nid=nnid).delete()
23     return redirect('/users')
24 def edit_user(request):
25     if request.method == 'GET':
26         nnid = request.GET.get('nid')
27         v = models.UserInfo.objects.filter(nid=nnid).first()
28         return render(request,'edit_user.html',{'obj':v})
29     elif request.method == 'POST':
30         nnid = request.POST.get('nid')
31         u = request.POST.get('user')
32         p = request.POST.get('pwd')
33         a = request.POST.get('age')
34         models.UserInfo.objects.filter(nid=nnid).update(username=u,pwd=p,age=a)
35         return redirect('/users')
36 def edit_user_new(request,nnid):   如果是动态路径，此处需要加参数，这个参数与路由系统中nnid所对应
37     if request.method == 'GET':    下面一部就不用获取nid了，因为在路径中已经获取了。
38         v = models.UserInfo.objects.filter(nid=nnid).first()
39         return render(request,'edit_user_new.html',{'obj':v})
40     elif request.method == 'POST':
41         u = request.POST.get('user')
42         p = request.POST.get('pwd')
43         a = request.POST.get('age')
44         models.UserInfo.objects.filter(nid=nnid).update(username=u, pwd=p, age=a)
45         return redirect('/users')
    views
     1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8     <h1>新编辑</h1>
 9     <form action="/edit_user_new-{{ obj.nid }}.html" method="POST">   由于已经回去了nid，这样就不用再次获取nid，所以也没必要隐藏了。
10         <input type="text" name="user" placeholder="用户名" value="{{ obj.username }}" />
11         <input type="text" name="pwd" placeholder="密码" value="{{ obj.pwd }}" />
12         <input type="text" name="age" placeholder="年龄" value="{{ obj.age}}" />
13         <input type="submit" value="提交">
14 
15     </form>
16 
17 
18 </body>
19 </html>
    edit_user_new.html
     1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8     <h1>用户列表</h1>
 9     <a href="/add_user">添加</a>
10     <ul>
11         {% for row in data %}
12         <li>
13         {{ row.nid}} - {{ row.username }} -
14         {{ row.pwd }}- {{ row.age }} -
15             <a href="/delete_user?nid={{ row.nid }}">删除</a> -
16             <a href="/edit_user?nid={{ row.nid }}">编辑</a> -
17             <a href="/edit_user_new-{{ row.nid }}.html">新编辑</a>
18         </li>
19         {% endfor %}
20     </ul>
21 </body>
22 </html>
    增加新编辑按钮

    1.url(r'^edit_user_new-(d+).html$', views.edit_user_new,name='bbb'),
    {% url "bbb" 1 %} ==> edit_user_new-1.html 位置在相应html的form表单中的action
    2. url(r'^edit_user_new-(?P<nnid>d+).html$', views.edit_user_new, name='nnn'),
    {% url "nnn" nnid=1 %} ==> edit_user_new-1.html

    url的分发

    多个app时，防止urls出错，各自写在自己的urls中

    导入include模块

    主urls
    url(r'^A2/',include('A2.urls')),
    url(r'^A3/',include('A3.urls')),

    A2 urls

    from django.conf.urls import url, include
    from django.contrib import admin
    from A2 import views
    urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^test/', views.test),

    ]

    A2 views
    from django.shortcuts import render
    from django.shortcuts import HttpResponse
    # Create your views here.
    def test(request):
    return HttpResponse('A2.test')


    A3 urls

    from django.conf.urls import url, include
    from django.contrib import admin
    from A3 import views
    urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^test/', views.test),

    ]

    A3 views
    from django.shortcuts import render
    from django.shortcuts import HttpResponse
    # Create your views here.
    def test(request):
    return HttpResponse('A3.test')

    视图函数 views.py    

    获取请求信息：        

    request.POST  {'username':'root'..}   对request.body的处理。        

    request.GET        

    request.FILES        

    request.method        

    request.body = username=root;age=18;gender=male

    request.FILES实例

    1 from django.conf.urls import url, include
2 from django.contrib import admin
3 from A2 import views
4 urlpatterns = [
5     url(r'^admin/', admin.site.urls),
6     url(r'^test/', views.test),
7     url(r'^upload', views.upload),
8 
9 ]
    urls
     1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8     <form action="/A2/upload" method="POST" enctype="multipart/form-data">
 9         <input type="file" name="fafafa" />
10         <input type="submit" value="提交">
11     </form>
12 
13 </body>
14 </html>
    upload.html
     1 from django.shortcuts import render
 2 from django.shortcuts import HttpResponse
 3 # Create your views here.
 4 def test(request):
 5     return HttpResponse('A2.test')
 6 def upload(request):
 7     if request.method == 'GET':
 8         return render(request,'upload.html')
 9     elif request.method == 'POST':
10         obj = request.FILES.get('fafafa')    #获取文件的方式
11         import os
12         f = open(os.path.join('upload',obj.name),'wb')
13         for line in obj.chunks():   #chunks是个迭代器
14             f.write(line)
15         f.close()
16         return HttpResponse('ok')
    views

     响应结果：        

    return HttpReponse(..)        

    return render(request,'path/a.html',{})        

    return redirect('http://www.baidu.com')    

    模板引擎

    本质上就是做替换

    特殊规则：
    - 1
    {{k1}}       获取单值，

    - 2
    {% if a == 123 %}

    {% else %}

    {% endif %}

    - 3
    {% for item in LIST %}
    {{item}}
    {% endfor %}
    - 4
    # 索引：字典.k1 列表.1     只能是点，没有类似于字典或者列表的那种取值方法

    - 5.自定义模板方法
    - filter: 在if条件中做条件时
    - simple_tag: 在页面仅显示内容时

    - 6. extends
    - 模板的继承 

    在基础模板中留有继承的位置，用{% block body %}和{% endblock %}所包含的内容替换基础模板中{% block body %}和{% endblock %}的位置。

    - 7. include
    - 导入公共组件
           

    方法：

    • {{ item.event_start|date:"Y-m-d H:i:s"}}  将日期格式变为引号中的格式。
    • {{ bio|truncatewords:"30" }}                   截取前30个单词

    urls

    url(r'^tpl',views.tpl),

    views

    def tpl(request):
    return render(request,'tpl.html',{'summary':'wewewewewewew'})

    tpl.html


    <!DOCTYPE html>
    <html lang="en">
    <head>
    <meta charset="UTF-8">
    <title>Title</title>
    </head>
    <body>
    {{ summary }}
    <br/>
    {{ summary | truncatechars:8 }}
    </body>
    </html>

    自定义simple_tag

    比如我想创建一个{{ summary | ji}}的方法

    a、在app中创建templatetags模块

    b、创建任意 .py 文件，如：xx.py

    url(r'^tpl',views.tpl),
    1 from django import template
2 register = template.Library()
3 @register.filter
4 def ji(value):
5     return 'jijiji'
    xxoo.py

    如果在文件中写入value值，那么ji前面的summary就会没当作参数传入进去

    {{ summary | ji}}

    @register.filter    filter只能穿两个值
    def ji(value):
    return 'jijiji----->' + value  ，此时summary对应的值就会被传进去，value就对应的是ji前面的summary

    c、在使用自定义simple_tag的html文件中导入之前创建的 xx.py 文件名

    如果是{{ summary | ji:8}},就表示可以传入两个参数

    def ji(value,num):
    return 'jijiji----->' + value  +str(num)

    最多能加两个参数

     1 {% load xxoo %}
 2 <!DOCTYPE html>
 3 <html lang="en">
 4 <head>
 5     <meta charset="UTF-8">
 6     <title>Title</title>
 7 </head>
 8 <body>
 9     {{ summary }}
10     <br/>
11     {{ summary | truncatechars:8 }}
12     <br/>
13     {{ summary | ji}}
14 </body>
15 </html>
    tpl.html

    d、使用simple_tag

    e、在settings中配置当前app，不然django无法找到自定义的simple_tag

    作用：

    from django.utils.safestring import mark_safe  #导入这个模块就是将tmp转化为html的格式

     1 from django import template
 2 register = template.Library()
 3 from django.utils.safestring import mark_safe
 4 @register.filter
 5 def ji(value,num):
 6     return 'jijiji----->' + value + str(num)
 7 @register.filter
 8 def ya(value,num):
 9     #value就是跳转
10     #num 就是8
11     tmp = "<a href='http://www.baidu.com?t=%s'>%s</a>" %(num,value,)
12     return mark_safe(tmp)
    xxoo.py
     1 {% load xxoo %}
 2 <!DOCTYPE html>
 3 <html lang="en">
 4 <head>
 5     <meta charset="UTF-8">
 6     <title>Title</title>
 7 </head>
 8 <body>
 9     {{ summary }}
10     <br/>
11     {{ summary | truncatechars:8 }}
12     <br/>
13     {{ summary | ji:8}}
14     <br/>
15     {{ '跳转'| ya:8 }}
16 </body>
17 </html>
    tpl.html

     实例：模版的继承

    不同页面，有相同的元素。

    一般预留位置有3个，一个是内容，一个是css，一个是js。

     1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title></title>
 6     <style>
 7         body{
 8             margin: 0;
 9         }
10         .pg-header{
11             height: 48px;
12             background-color: green;
13             color: white;
14         }
15         .pg-body .menus{
16              20%;
17             float: left;
18             background-color: black;
19             height: 500px;
20         }
21         .pg-body .contents{
22              80%;
23             float: left;
24         }
25     </style>
26     {% block css %}{% endblock %}
27 </head>
28 <body>
29     <div class="pg-header">
30         LLLLLLL
31     </div>
32     <div class="pg-body">
33         <div class="menus"></div>
34         <div class="contents">
35             {% block bd %}{% endblock %}
36         </div>
37     </div>
38     {% block js %}{% endblock %}
39 </body>
40 </html>
    公用模版
     1 {% extends 'layout.html' %}
 2 
 3 {% block css %}
 4     <style>
 5 
 6     </style>
 7 {% endblock %}
 8 
 9 {% block bd %}
10     <h1>组列表</h1>
11     ...
12 {% endblock %}
13 
14 
15 {% block js %}
16     <script></script>
17 {% endblock %}
    继承公用模版

    引用那个内容，要写相应的名字。

    公共组件，比如有分页，点下一页，页面变化，但是下面的分页不变

    写入到另一个页面，通过include解决

    1 <div>
2     <a>上一页</a>
3     <a>1</a>
4     <a>2</a>
5     <a>3</a>
6     <a>4</a>
7     <a>下一页</a>
8 </div>
    写入新的小组件
     1 {% extends 'layout.html' %}
 2 
 3 {% block css %}
 4     <style>
 5 
 6     </style>
 7 {% endblock %}
 8 
 9 {% block bd %}
10     <h1>组列表</h1>
11     ...
12     {% include 'pager.html' %}
13 {% endblock %}
14 
15 
16 {% block js %}
17     <script></script>
18 {% endblock %}
    include导入

    Cookie 

    - 是用户浏览器上的一个键值对        

    - 设置超时时间        

    利用cookie可实现：        

    - 登录验证        

    -页面显示条数        

    - 拖动位置..

    -显示内容，可以选择显示10条，20条.......

    例子：

    urls


    url(r'^login$',views.login),

     1 <!DOCTYPE html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Title</title>
 6 </head>
 7 <body>
 8     <form action="/login" method="POST">
 9         <input type="text" name="user" />
10         <input type="password" name="pwd" />
11         <input type="submit" value="登陆" /> {{ msg }}
12     </form>
13 </body>
14 </html>
    login.html
     1 from django.shortcuts import render
 2 from django.shortcuts import HttpResponse
 3 from A1 import models
 4 from django.shortcuts import redirect
 5 # Create your views here.
 6 def users(request):
 7     #摸口袋，有可以执行，没有重定向到login页面
 8     v = request.COOKIES.get('user_name')
 9     if not v:
10         return redirect('/login')
11 
12 
13 
14     users_list = models.UserInfo.objects.all()
15     return render(request,'users.html',{'data':users_list})
16 def add_user(request):
17     if request.method == 'GET':
18         return render(request,'add_user.html ')
19     elif request.method == 'POST':
20         u = request.POST.get('user')
21         p = request.POST.get('pwd')
22         a = request.POST.get('age')
23         # obj = models.UserInfo(username=u,pwd=p,age=a)
24         # obj.save()
25         models.UserInfo.objects.create(username=u,pwd=p,age=a)
26         return redirect('/users')
27 def delete_user(request):
28     nnid = request.GET.get('nid')
29     models.UserInfo.objects.filter(nid=nnid).delete()
30     return redirect('/users')
31 def edit_user(request):
32     if request.method == 'GET':
33         nnid = request.GET.get('nid')
34         v = models.UserInfo.objects.filter(nid=nnid).first()
35         return render(request,'edit_user.html',{'obj':v})
36     elif request.method == 'POST':
37         nnid = request.POST.get('nid')
38         u = request.POST.get('user')
39         p = request.POST.get('pwd')
40         a = request.POST.get('age')
41         models.UserInfo.objects.filter(nid=nnid).update(username=u,pwd=p,age=a)
42         return redirect('/users')
43 def edit_user_new(request,nnid):
44     if request.method == 'GET':
45         v = models.UserInfo.objects.filter(nid=nnid).first()
46         return render(request,'edit_user_new.html',{'obj':v})
47     elif request.method == 'POST':
48         u = request.POST.get('user')
49         p = request.POST.get('pwd')
50         a = request.POST.get('age')
51         models.UserInfo.objects.filter(nid=nnid).update(username=u, pwd=p, age=a)
52         return redirect('/users')
53 def tpl(request):
54     return render(request,'tpl.html',{'summary':'wewewewewewew'})
55 
56 def login(request):
57     if request.method == 'GET':
58         return render(request,'login.html')
59     elif request.method == 'POST':
60         u = request.POST.get('user')
61         p = request.POST.get('pwd')
62         obj = models.UserInfo.objects.filter(username=u,pwd=p).first()
63         if obj:
64             #在请求这口袋放东西
65             obj = redirect('/users')
66             obj.set_cookie(key='user_name',value=u,max_age=10,)#max_age 超时时间,expires当前时间，path，在那个url下生效，比如path=/index，只有index页面过来才能生效，不写默认是全局,httponly=True,http传输secure=True，https传输
67 
68             return obj
69         else:
70             return render(request,'login.html',{'msg':'用户名或密码错误'})
    views

       

    两大忌讳：   

          - 敏感信息   

          - 简单

    Session    

    - 放置在服务器端的键值对    

    随机字符串，双方都有，用户登陆时，会拿随机字符串，但并不认为登陆成功，要与自己服务器上的字符串进行比对。    

    session = {         'asdfasdfasd': {'username':'hailong'},         'asdfasdfasdf': {username:'feinikesi'},     }      

    views会有变动

     1 from django.shortcuts import render
 2 from django.shortcuts import HttpResponse
 3 from A1 import models
 4 from django.shortcuts import redirect
 5 # Create your views here.
 6 def users(request):
 7     #摸口袋，有可以执行，没有重定向到login页面
 8     # v = request.COOKIES.get('user_name')
 9     v = request.session.get('user_name')
10     if not v:
11         return redirect('/login')
12 
13 
14 
15     users_list = models.UserInfo.objects.all()
16     return render(request,'users.html',{'data':users_list})
17 def add_user(request):
18     if request.method == 'GET':
19         return render(request,'add_user.html ')
20     elif request.method == 'POST':
21         u = request.POST.get('user')
22         p = request.POST.get('pwd')
23         a = request.POST.get('age')
24         # obj = models.UserInfo(username=u,pwd=p,age=a)
25         # obj.save()
26         models.UserInfo.objects.create(username=u,pwd=p,age=a)
27         return redirect('/users')
28 def delete_user(request):
29     nnid = request.GET.get('nid')
30     models.UserInfo.objects.filter(nid=nnid).delete()
31     return redirect('/users')
32 def edit_user(request):
33     if request.method == 'GET':
34         nnid = request.GET.get('nid')
35         v = models.UserInfo.objects.filter(nid=nnid).first()
36         return render(request,'edit_user.html',{'obj':v})
37     elif request.method == 'POST':
38         nnid = request.POST.get('nid')
39         u = request.POST.get('user')
40         p = request.POST.get('pwd')
41         a = request.POST.get('age')
42         models.UserInfo.objects.filter(nid=nnid).update(username=u,pwd=p,age=a)
43         return redirect('/users')
44 def edit_user_new(request,nnid):
45     if request.method == 'GET':
46         v = models.UserInfo.objects.filter(nid=nnid).first()
47         return render(request,'edit_user_new.html',{'obj':v})
48     elif request.method == 'POST':
49         u = request.POST.get('user')
50         p = request.POST.get('pwd')
51         a = request.POST.get('age')
52         models.UserInfo.objects.filter(nid=nnid).update(username=u, pwd=p, age=a)
53         return redirect('/users')
54 def tpl(request):
55     return render(request,'tpl.html',{'summary':'wewewewewewew'})
56 
57 def login(request):
58     if request.method == 'GET':
59         return render(request,'login.html')
60     elif request.method == 'POST':
61         u = request.POST.get('user')
62         p = request.POST.get('pwd')
63         obj = models.UserInfo.objects.filter(username=u,pwd=p).first()
64         if obj:
65             #在请求这口袋放东西
66             obj = redirect('/users')
67             # obj.set_cookie(key='user_name',value=u,max_age=10,)#max_age 超时时间,expires当前时间，path，在那个url下生效，比如path=/index，只有index页面过来才能生效，不写默认是全局,httponly=True,http传输secure=True，https传输
68             request.session['user_name'] = u
69             return obj
70         else:
71             return render(request,'login.html',{'msg':'用户名或密码错误'})
    session views

    django的session字符串默认放在数据库中

    session的配置

    Django中默认支持Session，其内部提供了5种类型的Session供开发者使用：

    • 数据库（默认）
    • 缓存
    • 文件
    • 缓存+数据库
    • 加密cookie

    数据库

      1 Django默认支持Session，并且默认是将Session数据存储在数据库中，即：django_session 表中。
  2 
  3  
  4 
  5 a. 配置 settings.py
  6 
  7  
  8 
  9     SESSION_ENGINE = 'django.contrib.sessions.backends.db'   # 引擎（默认）
 10 
 11      
 12 
 13     SESSION_COOKIE_NAME ＝ "sessionid"                       # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串（默认）
 14 
 15     SESSION_COOKIE_PATH ＝ "/"                               # Session的cookie保存的路径（默认）
 16 
 17     SESSION_COOKIE_DOMAIN = None                             # Session的cookie保存的域名（默认）
 18 
 19     SESSION_COOKIE_SECURE = False                            # 是否Https传输cookie（默认）
 20 
 21     SESSION_COOKIE_HTTPONLY = True                           # 是否Session的cookie只支持http传输（默认）
 22 
 23     SESSION_COOKIE_AGE = 1209600                             # Session的cookie失效日期（2周）（默认）
 24 
 25     SESSION_EXPIRE_AT_BROWSER_CLOSE = False                  # 是否关闭浏览器使得Session过期（默认）
 26 
 27     SESSION_SAVE_EVERY_REQUEST = False                       # 是否每次请求都保存Session，默认修改之后才保存（默认）
 28 
 29  
 30 
 31  
 32 
 33  
 34 
 35 b. 使用
 36 
 37  
 38 
 39     def index(request):
 40 
 41         # 获取、设置、删除Session中数据
 42 
 43         request.session['k1']
 44 
 45         request.session.get('k1',None)
 46 
 47         request.session['k1'] = 123
 48 
 49         request.session.setdefault('k1',123) # 存在则不设置
 50 
 51         del request.session['k1']
 52 
 53  
 54 
 55         # 所有 键、值、键值对
 56 
 57         request.session.keys()
 58 
 59         request.session.values()
 60 
 61         request.session.items()
 62 
 63         request.session.iterkeys()
 64 
 65         request.session.itervalues()
 66 
 67         request.session.iteritems()
 68 
 69  
 70 
 71  
 72 
 73         # 用户session的随机字符串
 74 
 75         request.session.session_key
 76 
 77  
 78 
 79         # 将所有Session失效日期小于当前日期的数据删除
 80 
 81         request.session.clear_expired()
 82 
 83  
 84 
 85         # 检查 用户session的随机字符串 在数据库中是否
 86 
 87         request.session.exists("session_key")
 88 
 89  
 90 
 91         # 删除当前用户的所有Session数据
 92 
 93         request.session.delete("session_key")
 94 
 95  
 96 
 97         request.session.set_expiry(value)
 98 
 99             * 如果value是个整数，session会在些秒数后失效。
100 
101             * 如果value是个datatime或timedelta，session就会在这个时间后失效。
102 
103             * 如果value是0,用户关闭浏览器session就会失效。
104 
105             * 如果value是None,session会依赖全局session失效策略。
    session的配置

    缓存

     1 a. 配置 settings.py
 2 
 3  
 4 
 5     SESSION_ENGINE = 'django.contrib.sessions.backends.cache'  # 引擎
 6 
 7     SESSION_CACHE_ALIAS = 'default'                            # 使用的缓存别名（默认内存缓存，也可以是memcache），此处别名依赖缓存的设置
 8 
 9  
10 
11  
12 
13     SESSION_COOKIE_NAME ＝ "sessionid"                        # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串
14 
15     SESSION_COOKIE_PATH ＝ "/"                                # Session的cookie保存的路径
16 
17     SESSION_COOKIE_DOMAIN = None                              # Session的cookie保存的域名
18 
19     SESSION_COOKIE_SECURE = False                             # 是否Https传输cookie
20 
21     SESSION_COOKIE_HTTPONLY = True                            # 是否Session的cookie只支持http传输
22 
23     SESSION_COOKIE_AGE = 1209600                              # Session的cookie失效日期（2周）
24 
25     SESSION_EXPIRE_AT_BROWSER_CLOSE = False                   # 是否关闭浏览器使得Session过期
26 
27     SESSION_SAVE_EVERY_REQUEST = False                        # 是否每次请求都保存Session，默认修改之后才保存
28 
29  
30 
31  
32 
33  
34 
35 b. 使用
36 
37  
38 
39     同上
    View Code

    文件Session

     1 a. 配置 settings.py
 2 
 3  
 4 
 5     SESSION_ENGINE = 'django.contrib.sessions.backends.file'    # 引擎
 6 
 7     SESSION_FILE_PATH = None                                    # 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir()                                                            # 如：/var/folders/d3/j9tj0gz93dg06bmwxmhh6_xm0000gn/T 
 8 
 9  
10 
11  
12 
13     SESSION_COOKIE_NAME ＝ "sessionid"                          # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串
14 
15     SESSION_COOKIE_PATH ＝ "/"                                  # Session的cookie保存的路径
16 
17     SESSION_COOKIE_DOMAIN = None                                # Session的cookie保存的域名
18 
19     SESSION_COOKIE_SECURE = False                               # 是否Https传输cookie
20 
21     SESSION_COOKIE_HTTPONLY = True                              # 是否Session的cookie只支持http传输
22 
23     SESSION_COOKIE_AGE = 1209600                                # Session的cookie失效日期（2周）
24 
25     SESSION_EXPIRE_AT_BROWSER_CLOSE = False                     # 是否关闭浏览器使得Session过期
26 
27     SESSION_SAVE_EVERY_REQUEST = False                          # 是否每次请求都保存Session，默认修改之后才保存
28 
29  
30 
31 b. 使用
32 
33  
34 
35     同上
    View Code

    缓存+数据库Session

     1 数据库用于做持久化，缓存用于提高效率
 2 
 3  
 4 
 5 a. 配置 settings.py
 6 
 7  
 8 
 9     SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'        # 引擎
10 
11  
12 
13 b. 使用
14 
15  
16 
17     同上
    View Code

    加密cookie Session

     1 a. 配置 settings.py
 2 
 3      
 4 
 5     SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies'   # 引擎
 6 
 7  
 8 
 9 b. 使用
10 
11  
12 
13     同上
    View Code

          
  • 相关阅读:
    OPENSSH 详解
    红帽RHEL8和7有什么区别（Centos8与7参照redhat）
    RHEL8和CentOS8怎么重启网络
    Redhat7.x Openssh、Openssl升级
    RHEL7.x更换更换Centos yum源
    NTP时间同步
    2019-12-17：权限维持，笔记
    2019-12-13:提权学习，笔记
    2019-12-11：kali linux工具Msfvenom 命令自动补全
    2019-12-10：win7,win12提权练习
  • 原文地址：https://www.cnblogs.com/l-w-q/p/6516008.html
Copyright © 2011-2022 走看看