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

          
  • 相关阅读:
    2. Add Two Numbers
    1. Two Sum
    leetcode 213. 打家劫舍 II JAVA
    leetcode 48. 旋转图像 java
    leetcode 45. 跳跃游戏 II JAVA
    leetcode 42. 接雨水 JAVA
    40. 组合总和 II leetcode JAVA
    24. 两两交换链表中的节点 leetcode
    1002. 查找常用字符 leecode
    leetcode 23. 合并K个排序链表 JAVA
  • 原文地址：https://www.cnblogs.com/l-w-q/p/6516008.html
Copyright © 2011-2022 走看看