devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Django Web开发基础知识

作者：不正经 | 2024-02-10 09:42:00

赞

踩

django web开发

Django是一个开源的Web框架，用于使用Python语言构建Web应用程序。它由一个高度可重用和可插拔的组件集合构成，使得开发者能够更快速、更轻松地构建功能强大的Web应用。Django采用了MVC（Model-View-Controller）的设计模式，但在Django中通常被称为MTV（Model-Template-View）。

以下是Django的一些关键特性和组件：

主要特性：

  1. 强大的ORM： Django内置了ORM系统，允许开发者使用Python代码而不是SQL语句与数据库交互。这简化了数据库操作和迁移过程。

  2. 模型-模板-视图（MTV）设计： Django采用了一种清晰的MTV设计模式，将应用程序的逻辑分成模型（数据层）、模板（表示层）和视图（业务逻辑层）。

  3. 自动化Admin界面： Django自动为模型生成管理界面，允许开发者轻松进行数据管理和查看。

  4. 强大的URL映射： Django使用灵活的URL映射机制，通过简单的配置，将URL映射到视图函数，使得URL管理变得简单而直观。

  5. 表单处理： Django提供了用于处理表单的强大机制，简化了用户输入的验证和处理。

  6. 安全性： Django内置了许多安全性功能，如防止CSRF攻击、XSS攻击和SQL注入。

  7. 多语言支持： Django支持多语言和多时区，允许开发者构建全球化的Web应用。

  8. 插件和可插拔应用： Django的可插拔应用机制使得开发者能够轻松集成第三方应用，并重用已有的代码。

Django组件：

  1. 模型（Model）： 数据库的映射，定义了数据的结构和行为。

  2. 视图（View）： 处理Web应用的业务逻辑，负责接收请求、处理数据、调用模板等。

  3. 模板（Template）： 页面的呈现和展示，通过模板语言嵌入动态数据。

  4. 控制器（Controller）： Django中的控制器的功能由视图和URL映射共同完成。

  5. URLconf： URL配置，将URL映射到对应的视图函数。

  6. 中间件（Middleware）： 提供处理请求和响应的钩子，用于实现全局功能，如安全性检查、缓存等。

Django是一个全面且高度集成的框架，适用于各种规模的Web应用程序开发。其开发方式注重代码的清晰性、可维护性和可扩展性，为开发者提供了一套强大而灵活的工具。

MVC与MTV

MVC - Model View Controller，模型(model)－视图(view)－控制器(controller)的缩写，是软件工程中的一种软件架构模式，Model模型中主要用于存储与数据库相关的字段或数据库通信方面的东西，Controller控制器用于存储URL的分发等，最后的View视图则是完善控制器中的路径分发，每一个路径对应一个view视图函数。

模型(M)，控制器(C)和视图(V)三层，他们之间以一种插件式的、松耦合的方式连接在一起:

A.模型负责业务对象与数据库的映射(ORM)
B.视图负责与用户的交互(页面)
C.控制器接受用户的输入调用模型和视图完成用户的请求

ORM：对象关系映射(Object Relational Mapping，简称ORM，或O/RM，或O/R mapping)

通常情况下我们写代码用的是面向对象的方法，而我们的数据库无法支持面向对象的编程，为了解决两者之间的不同，就出现了ORM映射技术，使用这种技术我们无需关注sql语句的具体编写，只需要使用特定的API即可完成复杂的查询删除等任务，但有一个缺点，采用此技术在一定程度上会消耗系统部分资源，而对于非常复杂的查询工作，还是要使用纯SQL语句来写。

Django的MTV模式本质上和MVC是一样的，也是为了各组件间保持松耦合关系，只是定义上有些许不同，Django的MTV分别是值：

M 代表模型(Model)： 负责业务对象和数据库的关系映射(ORM)。
T 代表模板 (Template)：负责如何把页面展示给用户(html)。
V 代表视图(View)： 负责业务逻辑，并在适当时候调用Model和Template。

除了以上三层之外，还需要一个URL分发器，它的作用是将一个个URL的页面请求分发给不同的View处理，View再调用相应的Model和Template，MTV的响应模式如下所示：

这种设计模式优势在于各组件都是松耦合的。每个由Django驱动的Web应用都有着明确的目的，并且可独立更改而不影响到其它的部分。

HTTP协议：Hyper Text Transfer Protocol(超文本传输协议)，是用于万维网服务器与本地浏览器之间传输超文本的传送协议。

该协议是基于TCP/IP的请求协议

HTTP协议规定,请求从客户端发出,最后服务器端响应该请求并 返回。换句话说,肯定是先从客户端开始建立通信的,服务器端在没有 接收到请求之前不会发送响应无状态保存

HTTP是一种不保存状态,即无状态(stateless)协议。HTTP协议自身不对请求和响应之间的通信状态进行保存,协议对于发送过的请求或响应都不做持久化处理。

无连接:无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接。采用这种方式可以节省传输时间。

HTTP请求方式

GET提交的数据会放在URL之后，以?分割URL和传输数据，参数之间以&相连，POST方法是把提交的数据放在HTTP包的Body中.
GET提交的数据大小有限制(因为浏览器对URL的长度有限制)，而POST方法提交的数据没有限制.
GET与POST请求在服务端获取请求数据方式不同。
GET方式提交数据，会带来安全问题，而POST请求则相对安全。

第一个django项目

1.如果是使用Pycharm创建的项目,直接创建项目，即可。

2.如果没有创建app的名字，也可以在进入django目录中，执行 python manage.py startapp MyWeb 命令创建.

更多django shell命令行参数。

  1. python manage.py shell     #进入django shell
  2. python manage.py dbshell   #进入django dbshell
  3. python manage.py check     #检查django项目完整性
  4. python manage.py flush     #清空数据库
  5. python manage.py compilemessages   #编译语言文件
  6. python manage.py makemessages      #创建语言文件
  7. python manage.py showmigrations    #查看生成的数据库同步脚本
  8. python manage.py sqlflush          #查看生成清空数据库的脚本
  9. python manage.py sqlmigrate        #查看数据库同步的sql语句
  10. python manage.py dumpdata          #导出数据
  11. python manage.py loaddata          #导入数据
  12. python manage.py diffsettings      #查看你的配置和django默认配置的不同之处

2.修改settings.py 配置文件,导入我们的app的名字，去掉csrf这个选项

  1. MIDDLEWARE = [
  2. 'django.middleware.csrf.CsrfViewMiddleware',  # 为了能够开心玩耍,把这个干掉
  3. ]
  4.  
  5. INSTALLED_APPS = [
  6.     'django.contrib.admin',
  7.     'django.contrib.auth',
  8.     'django.contrib.contenttypes',
  9.     'django.contrib.sessions',
  10.     'django.contrib.messages',
  11.     'django.contrib.staticfiles',
  12.     'MyWeb.apps.MywebConfig'           # 导入
  13. ]

3.来urls.py里面写一条路由，名字就叫hello , 映射到views.hello函数下处理此请求。

  1. from MyWeb import views       # 导入
  2.  
  3. urlpatterns = [
  4.     path('admin/', admin.site.urls),
  5.     path('hello/',views.hello)
  6. ]

4.最后在myweb里面的views.py设置一个视图函数,最后运行。

  1. from django.shortcuts import HttpResponse
  2.  
  3. # Create your views here.
  4. # 这个request必须加,不然会报错
  5. def hello(request):
  6.     return HttpResponse("<h1>hello lyshark</h1>")

5.配置好以后，启动django,访问 http://127.0.0.1:8000/ 完成了。

6.如果需要引入静态资源，需要设置一下settings.py

  1. # Static files (CSS, JavaScript, Images)
  2. # https://docs.djangoproject.com/en/3.0/howto/static-files/
  3.  
  4. # 这个路径是对应 src="/static/ 的别名
  5. # 如果这个路径改为 STATIC_URL = '/abc/' 那么<script src="/abc/xxx.js"></script>
  6. STATIC_URL = '/static/'
  7. STATICFILES_DIRS = (
  8.     os.path.join(BASE_DIR,'static'),
  9. )

Django 初始化操作

初始化Django

  1. D:\> pip install django                              # 安装
  2. D:\> django-admin startproject MyProject             # 创建项目
  3. D:\MyProject> django-admin startapp MyWeb            # 创建APP
  4. D:\MyProject> python manage.py runserver 0.0.0.0:80  # 启动Django
  5.  
  6. D:\MyProject> python manage.py shell   # 进入Django交互shell
  7. D:\MyProject> python manage.py dbshell # 进入DBShell
  8. D:\MyProject> python manage.py check   # 检查Django完整性

修改一下django的配置文件settings.py,导入我们生成APP的名字.

  1. MIDDLEWARE = [
  2.     'django.middleware.security.SecurityMiddleware',
  3.     'django.contrib.sessions.middleware.SessionMiddleware',
  4.     'django.middleware.common.CommonMiddleware',
  5.     #'django.middleware.csrf.CsrfViewMiddleware',                # 注释掉此行
  6.     'django.contrib.auth.middleware.AuthenticationMiddleware',
  7. ]
  8. INSTALLED_APPS = [
  9.     'django.contrib.admin',
  10.     'django.contrib.auth',
  11.     'django.contrib.contenttypes',
  12.     'django.contrib.sessions',
  13.     'django.contrib.messages',
  14.     'django.contrib.staticfiles',
  15.     'MyWeb.apps.MywebConfig'           # 添加此行,导入我们的APP的名字
  16. ]

然会修改urls.py在这里写一条路由记录.

  1. from MyWeb import views
  2.  
  3. urlpatterns = [
  4.     path('admin/', admin.site.urls),
  5.     path("hello/",views.hello,name="hello")
  6. ]

最后我们在views.py视图函数里添加一条路由.

  1. from django.shortcuts import HttpResponse
  2.  
  3. def hello(request):
  4.     return HttpResponse("<h1>hello lyshark</h1>")

有时候我们需要在本地引入JS或者静态资源,此时你需要修改一下Django的setting.py里面的路径.

  1. # Static files (CSS, JavaScript, Images)
  2. # https://docs.djangoproject.com/en/3.0/howto/static-files/
  3. # 此时我们的默认路径是/static/,那么前端就可以直接调用<script src="/static/lyshark.js">
  4. STATIC_URL = '/static/'
  5. STATICFILES_DIRS=(
  6.     os.path.join(BASE_DIR,'static')
  7. )

Django 模板与视图

简单的路由编写

  1. urlpatterns = [
  2.     path('admin/', admin.site.urls),
  3.     path('',views.index,name="index"),                                     # 一条访问主站的路由
  4.     path('login/id=<int:id>&name=<str:name>',views.login,name="login"),    # 名称后面传递参数
  5.     path('add/<int:x>/<int:y>/',views.add,name="add")                      # 路径中传递参数
  6. ]
  7.  
  8. from django.shortcuts import render,HttpResponse
  9. def index(request):
  10.     return render(request,"index.html")
  11.  
  12. def login(request, id, name):
  13.     return HttpResponse("用户ID{} , 用户名{} ".format(id,name))
  14.  
  15. def add(request,x,y):
  16.     temp = int(x)+int(y)
  17.     return HttpResponse("相加结果:{}".format(temp))

使用模板传递简单的参数

  1. **用户名: {{ user }} 密码:{{ pasd }} 标题:{{ title }}:**
  2.  
  3. def index(request):
  4.     username = "lyshark"
  5.     password = "123123"
  6.     title = "hello lyshark"
  7.     return render(request,"index.html",{"user":username,"pasd":password,"title":title})

后端组装数据然后传递给前端

  1. **用户名: {{ user }} 密码:{{ pasd }} 标题:{{ title }}:**
  2.  
  3. def index(request):
  4.     username = "admin"
  5.     password = "123123"
  6.     title = "hello lyshark"
  7.  
  8.     dict = {
  9.         "user": username,
  10.         "pasd": password,
  11.         "title": title
  12.     }
  13.     return render(request,"index.html",dict)

通过info变量遍历出指定字段元素

  1. **站点名称:{{ info.site }} 站点描述:{{ info.content }}:**
  2.  
  3. def index(request):
  4.     info = {"site":"blib.cn","content":"hello lyshark"}
  5.     return render(request,"index.html",{"info":info})

通过for语句遍历打印列表数据

  1. {% for item in total %}
  2.         **打印数据: {{ item }}:**<br>
  3.     {% endfor %}
  4.  
  5. def index(request):
  6.     lists = ["HTML","CSS","JAVASCRIPT","Python","JQuery"]
  7.     return render(request,"index.html",{"total":lists})

通过for语句倒序循环打印

  1. {% for item in total reversed%}
  2.         **打印数据: {{ item }}:**<br>
  3.     {% endfor %}
  4.  
  5. def index(request):
  6.     lists = ["1","2","3","4","5"]
  7.     return render(request,"index.html",{"total":lists})

通过使用for循环遍历字典

  1. {% for key,value in info.items %}
  2.     {{ key }} : {{ value }}
  3. {% endfor %}
  4.  
  5. def index(request):
  6.     info = {"site":"blib.cn","content":"hello lyshark"}
  7.     info1 = {"site": "blib.cn", "content": "hello admin"}
  8.  
  9.     return render(request,"index.html",{"info":info,"info1":info1})

简单的路径拼接

  1. <a href="{{ request.path }}?uid=1">当前网址加参数</a>
  2.  
  3. <!--获取当前路径      拼接成 /add/4/5-->
  4. {{ request.path }}{% url 'add' 4 5 %}
  5.  
  6. def add(request,x,y):
  7.     temp = int(x)+int(y)
  8.     return HttpResponse("相加结果:{}".format(temp))
  9.  
  10. def index(request):
  11.     return render(request,"index.html")

判断用户是否登录

  1. {% if request.user.is_authenticated %}
  2.     {{ request.user.username }}，您好！
  3. {% else %}
  4.     请登陆，这里放登陆链接
  5. {% endif %}

使用if语句判断数据

  1. {% if username == "lyshark" and password == "123123" %}
  2.     **恭喜你:**
  3. {% elif username == "admin" or password == "123123" %}
  4.     **欢迎管理员:**
  5. {% else %}
  6.     **这个都不是:**
  7. {% endif %}
  8.  
  9. def index(request):
  10.     username = "admin"
  11.     password = "123123"
  12.     return render(request,"index.html",{"username":username,"password":password})

if语句也可以判断列表元素

  1. {% if 1 in list %}
  2.     **在里面:**
  3. {% elif 10 not in list %}
  4.     ** 不在里面:**
  5. {% endif %}
  6.  
  7. def index(request):
  8.     list = [1,2,3,4,5]
  9.     return render(request,"index.html",{"list":list})

最后的大总结:if与for语句的结合

  1. {% for item in info %}
  2.     {% if forloop.first %}
  3.         **开始了:**
  4.     {% endif %}
  5.     {{ forloop.counter }} : {{ item }}<br>
  6.     {% if forloop.last %}
  7.         **最后了:**
  8.     {% endif %}
  9. {% endfor %}
  10.  
  11. def index(request):
  12.     list = map(str,range(100))
  13.     return render(request,"index.html",{"info":list})
  14.  
  15. forloop.counter 索引从 1 开始算
  16. forloop.counter0    索引从 0 开始算
  17. forloop.revcounter  索引从最大长度到 1
  18. forloop.revcounter0 索引从最大长度到 0
  19. forloop.first   当遍历的元素为第一项时为真
  20. forloop.last    当遍历的元素为最后一项时为真
  21. forloop.parentloop  
  22. 用在嵌套的 for 循环中，获取上一层 for 循环的 forloop

常用的过滤器

  1. ** 列表长度: {{ total | length }}:**<br>
  2.     ** 输出大小: {{ size | filesizeformat }}:**<br>
  3.     ** 输出时间: {{ date | date:"Y-m-d" }}:**<br>
  4.     ** 首字母大写: {{ title | capfirst }}:**<br>
  5.     ** 从字符串中移除hello字符: {{title | cut:"hello" }}:**<br>
  6.     ** 显示字符串第一个元素: {{ total | first }}:**<br>
  7.     ** 显示字符串最后一个元素: {{ total | last }}:**<br>
  8.     ** 大小写转换(upper/lower): {{ title | upper }}:**<br>
  9.     ** 对数据切片: {{ title | slice:"2:-1" }}:**<br>
  10.     **截断字符：{{ title | truncatechars:5 }}:**<br>
  11.     **截断单词：{{ title | truncatewords:1 }}:**
  12.  
  13. def index(request):
  14.     filesize = 10240
  15.     title = "hello lyshark"
  16.     date = datetime.datetime.now()
  17.     lists = ["1","2","3","4","5"]
  18.     return render(request,"index.html",{"total":lists,"size":filesize,"date":date,"title":title})

自定义过滤器与标签

1.首先在Django项目下的APP里面,创建一个templatetags的目录,这个目录名不能变.

  1. MyWeb/
  2.     __init__.py
  3.     models.py
  4.     templatetags/
  5.         __init__.py
  6.         mysimple.py
  7.     views.py

2.在templatetags目录下创建任意的py文件,此处我们就创建一个mysimple.py,并写入以下两条内容.

  1. from django import template
  2. from django.utils.safestring import mark_safe
  3.  
  4. register = template.Library() # 此处必须这样写
  5.  
  6. # simple_tag(自定义标签)：不会限制传参,但不支持if
  7. @register.simple_tag
  8. def simple_time(var1,var2,var3):
  9.     temp = int(var1)+int(var2)+int(var3)
  10.     return temp
  11.  
  12. # filter(自定义过滤器)：限制传参2个,但支持if
  13. @register.filter
  14. def My_filter(value, arg):
  15.     # 传递一个参数的过滤器
  16.     return str.upper(value) + arg

3.在我们需要使用自定义过滤器的时候,必须在index.html中引入这个变量,然后在前端就可以调用了.

  1. # name: views.py
  2. def index(request):
  3.     title = "hello"
  4.     return render(request,"index.html",{"title":title})
  5.  
  6. # name: index.html
  7. <!--引入自定义的过滤器-->
  8. {% load mysimple %}
  9.  
  10. **自定义标签返回数值: {% simple_time 10 20 30 %}:**          <!-- 传递多个参数 -->
  11. **传递一个参数的过滤器: {{ title | My_filter:'lyshark' }}:** <!-- 传递一个参数 -->

模板与模板继承

  1. 母板：             {% block title %}{% endblock %}
  2. 子板继承：         {% extends "base.html" %}
  3. 子板中使用其他模板: {% include "xx.html" %}
  4. 设置标题:          {% block title %}{% endblock %}
  5. 使用CSS资源:       {% block css %} {% endblock %}
  6. 使用JS资源:        {% block js %} {% endblock %}

1.首先创建一个base.html文件,以作为我们的母版.

  1. <html>
  2. <head>
  3.     <meta charset="UTF-8">
  4.     {% block css %}{% endblock %}
  5. </head>
  6.     <body>
  7.         <div class="pg-body">
  8.             <div class="body-menu">
  9.                 <ul>
  10.                     <li><a href="/user">用户管理</a></li>
  11.                     <li><a href="/hosts">资产管理</a></li>
  12.                 </ul>
  13.             </div>
  14.             <div class="body-content">
  15.                 {% block body %}{% endblock %}   <!--占位符,用于填充子版块-->
  16.             </div>
  17.         </div>
  18.         {% block js %}{% endblock %}
  19.     </body>
  20. </html>

接着我们需要创建一个子板并继承母版,此处我们创建一个hosts.html这样的文件.

  1. {% extends 'base.html' %}
  2. {% block js %} {% endblock %}
  3. {% block css %} {% endblock %}
  4.  
  5. {% block body %}
  6.     <table>
  7.         {% for item in host %}
  8.             <tr>
  9.                 <td>{{ item.hostname }}</td>
  10.                 <td>{{ item.port }}</td>
  11.             </tr>
  12.         {% endfor %}
  13.     </table>
  14. {% endblock %}

我们继续创建一个user.html,同样也是继承base.html模板.

  1. {% extends 'base.html' %}
  2.  
  3. {% block js %} {% endblock %}
  4. {% block css %} {% endblock %}
  5.  
  6. {% block body %}
  7.     <ul>
  8.     {% for item in user_list %}
  9.         <li>{{ item.username }},{{ item.salary }}</li>
  10.     {% endfor %}
  11.     </ul>
  12. {% endblock %}

此处我们需要在urls.py里面写好路由分发.

  1. from django.contrib import admin
  2. from django.urls import path
  3. from MyWeb import views
  4.  
  5. urlpatterns = [
  6.     path('admin/', admin.site.urls),
  7.     path('',views.index,name="index"),
  8.     path('hosts/',views.hosts,name="hosts"),
  9.     path('user/',views.userinfo,name="user")
  10. ]

然后写好views.py中的视图函数,默认我们返回base.html这个页面.

  1. from django.shortcuts import render
  2. from django.shortcuts import HttpResponse
  3.  
  4. def index(request):
  5.     return render(request,"base.html")
  6.  
  7. def hosts(request):
  8.     hosts_list = []
  9.     for i in range(10):
  10.         temp = {'hostname':'192.168.1.'+str(i),'port':80}
  11.         hosts_list.append(temp)
  12.     return render(request,'hosts.html',{'host':hosts_list})
  13.  
  14. def userinfo(request):
  15.     user_list = []
  16.     for i in range(10):
  17.         temp = {'username': 'user' + str(i),'salary':80}
  18.         user_list.append(temp)
  19.     return render(request,'user.html',{'user_list':user_list})

简单的用户登录

  1. # name:login.html
  2. <!DOCTYPE html>
  3. <body lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <title>Title</title>
  7. </head>
  8.     <form action="{% url 'login' %}" method="post">  # 通过模板获取到login的试图
  9.         <input type="text" name="username" />
  10.         <input type="text" name="password" />
  11.         <input type="submit" name="提交"/>
  12.     </form>
  13. </body>
  14. </html>
  15.  
  16. # name: urls.py
  17. from django.contrib import admin
  18. from django.urls import path
  19. from MyWeb import views
  20.  
  21. urlpatterns = [
  22.     path('admin/', admin.site.urls),
  23.     path('login/', views.login, name="login")  # name是给视图起一个名字
  24. ]
  25.  
  26. # name:views.py
  27. from django.shortcuts import render,HttpResponse
  28.  
  29. def login(request):
  30.     if request.method == "GET":
  31.         return render(request,"index.html")
  32.     elif request.method == "POST":
  33.         username = request.POST.get("username")
  34.         password = request.POST.get("password")
  35.         return HttpResponse("您提交的用户:{} 密码:{}".format(username,password))

Django 表单操作

普通Form表单的提交

  1. <!-- name:index.html -->
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <title>Title</title>
  7. </head>
  8. <body>
  9.     <form action="/" method="post">
  10.         <p>账号:<input type="text" name="username"><span>{{ error.username }}</span></p>
  11.         <p>密码:<input type="password" name="password"><span>{{ error.password }}</span></p>
  12.         <input type="submit" value="提交请求">
  13.     </form>
  14. </body>
  15. </html>
  1. # name: views.py
  2. from django.shortcuts import render,HttpResponse
  3.  
  4. def index(request):
  5.     if request.method == "GET":
  6.         return render(request,"index.html")
  7.     else:
  8.         username = request.POST.get("username")
  9.         password = request.POST.get("password")
  10.         error = {"username":"","password":""}
  11.         if len(username) > 10:
  12.             error["username"]="用户名不能大于10"
  13.         if len(password) < 5:
  14.             error["password"] = "密码不能小于5"
  15.         return render(request,"index.html",{"error":error})

实现单项选择框

  1. <form action="/index/" method="post">
  2.  
  3.     选择A:
  4.  
  5.     <select name="tag_select_a">
  6.  
  7.         {% for item in total_a %}
  8.  
  9.             <option value = "{{ item }}"> {{ item }} </option>
  10.  
  11.         {% endfor %}
  12.     </select>
  13.     选择B:
  14.     <select name="tag_select_b">
  15.         {% for item in total_b %}
  16.             <option value = "{{ item }}"> {{ item }} </option>
  17.         {% endfor %}
  18.     </select>
  19.     <input type="submit" value="提交选择">
  20. </form>
  1. def index(request):
  2.     if request.method == "GET":
  3.         tag_select_a = ["HTML", "CSS", "JAVASCRIPT", "Python", "JQuery"]
  4.         tag_select_b = ["MySQL","Oracle","MSSQL"]
  5.         return render(request, "index.html", {"total_a": tag_select_a,"total_b": tag_select_b})
  6.     elif request.method == "POST":
  7.         select_a = request.POST.get("tag_select_a")
  8.         select_b = request.POST.get("tag_select_b")
  9.         return HttpResponse("选择A: {} 选择B: {}".format(select_a,select_b))<b>普通Form表单的提交</b>

提交账号密码

  1. <!-- name:index.html -->
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <title>Title</title>
  7. </head>
  8. <body>
  9.     <form action="/" method="post">
  10.         <p>账号:<input type="text" name="username"><span>{{ error.username }}</span></p>
  11.         <p>密码:<input type="password" name="password"><span>{{ error.password }}</span></p>
  12.         <input type="submit" value="提交请求">
  13.     </form>
  14. </body>
  15. </html>
  1. # name: views.py
  2. from django.shortcuts import render,HttpResponse
  3.  
  4. def index(request):
  5.     if request.method == "GET":
  6.         return render(request,"index.html")
  7.     else:
  8.         username = request.POST.get("username")
  9.         password = request.POST.get("password")
  10.         error = {"username":"","password":""}
  11.         if len(username) > 10:
  12.             error["username"]="用户名不能大于10"
  13.         if len(password) < 5:
  14.             error["password"] = "密码不能小于5"
  15.         return render(request,"index.html",{"error":error})

Form实现登录表单

  1. <!--name:index.html-->
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <title>Title</title>
  7. </head>
  8. <body>
  9.     <form action="/" method="post" novalidate>
  10.         <p>账号: {{ form.username }} {{ form.username.errors.0 }}</p>
  11.         <p>密码: {{ form.password }} {{ form.errors.password }}</p>
  12.         <p>重复: {{ form.RepeatPass }} {{ form.errors.RepeatPass }}</p>
  13.         <input type="submit" value="提交">
  14.     </form>
  15. </body>
  16. </html>
  1. # name:views.py
  2. from django.shortcuts import render,HttpResponse
  3. from django.forms import Form,fields,widgets
  4. from django.core.exceptions import ValidationError
  5.  
  6. class LoginForm(Form):
  7.     username = fields.CharField(
  8.         required = True,
  9.         max_length = 10,
  10.         error_messages={"required":"该字段不能为空"},
  11.         widget=widgets.TextInput(attrs={"placeholder":"请输入用户名","class":"form-control"})
  12.     )
  13.     password = fields.CharField(
  14.         required = True,
  15.         max_length=10,
  16.         error_messages={"required":"密码字段不能为空","min_length":"密码最小长度为5"},
  17.         widget=widgets.PasswordInput(attrs={"placeholder":"请输入密码","class":"form-control"})
  18.     )
  19.     RepeatPass = fields.CharField(
  20.         required=True,
  21.         max_length=10,
  22.         error_messages={"required":"密码字段不能为空","min_length":"密码最小长度为5"},
  23.         widget=widgets.PasswordInput(attrs={"placeholder":"重复输入密码","class":"form-control"})
  24.     )
  25.  
  26.     # 自定义方法(局部钩子)密码必须包含字母和数字
  27.     def clean_password(self):
  28.         if self.cleaned_data.get("password").isdigit() or self.cleaned_data.get("password").isalpha():
  29.             raise ValidationError("密码必须包含数字和字母")
  30.         else:
  31.             return self.cleaned_data["password"]
  32.     # 自定义方法(全局钩子, 检验两个字段)，检验两次密码是否一致
  33.     def clean_RepeatPass(self):
  34.         if self.cleaned_data.get("password") != self.cleaned_data.get("RepeatPass"):
  35.             raise ValidationError("两次输入密码不正确")
  36.         else:
  37.             return self.cleaned_data
  38.  
  39. def index(request):
  40.     if request.method =="GET":
  41.         form = LoginForm()
  42.         return render(request, "index.html", {"form": form})
  43.     else:
  44.         form = LoginForm(request.POST)
  45.         if form.is_valid():
  46.             # username = form.data['username']
  47.             data = form.cleaned_data
  48.             username = data.get("username")
  49.             password = data.get("password")
  50.             print(username,password)
  51.             return render(request, "index.html", {"form": form})
  52.     return render(request, "index.html", {"form": form})

其他常用Form表单

  1. <!--name: index.html-->
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <title>Title</title>
  7. </head>
  8. <body>
  9.     <form action="/" method="post">
  10.         {% for field in form %}
  11.             <p>{{ field.label_tag }} {{ field }} {{ field.errors.0 }}</p>
  12.         {% endfor %}
  13.         <input type="submit" value="提交" />
  14.     </form>
  15. </body>
  16. </html>
  1. # name: views.py
  2. from django.shortcuts import render,HttpResponse
  3. from django.forms import Form,fields,widgets
  4.  
  5. class MyForm(Form):
  6.     hobby = fields.ChoiceField(
  7.         label="单选框:",
  8.         required=True,
  9.         initial=1,                # 默认选择1号
  10.         choices=( (1,"篮球"),(2,"足球"),(3,"乒乓球"),(4,"滚球")),
  11.         widget=widgets.RadioSelect()
  12.     )
  13.     select = fields.ChoiceField(
  14.         label="单选框(默认):",
  15.         required=True,
  16.         initial=1,
  17.         choices=( (1,"篮球"),(2,"足球"),(3,"乒乓球"),(4,"滚球")),
  18.         widget=widgets.Select()
  19.     )
  20.     multiple = fields.MultipleChoiceField(
  21.         label="复选框",
  22.         choices=((1, "篮球"), (2, "足球"), (3, "羽毛球"), (4, "排球")),
  23.         initial=[2, 4],
  24.         widget=widgets.SelectMultiple()
  25.     )
  26.     checkbox = fields.ChoiceField(
  27.         label="单项复选框",
  28.         initial="checked",  # 默认为勾选
  29.         widget=widgets.CheckboxInput()
  30.     )
  31.     multselect = fields.MultipleChoiceField(
  32.         label="多项复选框",
  33.         choices=((1, "篮球"), (2, "足球"), (3, "羽毛球"), (4, "排球")),
  34.         initial=[1, 3],
  35.         widget=widgets.CheckboxSelectMultiple()
  36.     )
  37.     data = fields.DateField(
  38.         label="选择日期",
  39.         widget = widgets.DateInput(attrs={"type":"date"})
  40.     )
  41. def index(request):
  42.     if request.method=="GET":
  43.         form = MyForm()
  44.         return render(request,"index.html",{"form":form})
  45.     else:
  46.         form = MyForm(request.POST)
  47.         if form.is_valid():
  48.             data = form.cleaned_data
  49.             print(data.get("hobby"))
  50.     return HttpResponse("hello lyshark")

Form实现用户注册

  1. <!--name: index.html-->
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <title>Title</title>
  7. </head>
  8. <body>
  9.     <div>
  10.         <form action="/" method="post">
  11.             <p>{{ form.username.label }} {{ form.username }}</p>
  12.             <p>{{ form.password.label }} {{ form.password }}</p>
  13.             <p>{{ form.mobile.label }} {{ form.mobile }} </p>
  14.             <p>{{ form.email.label }} {{ form.email }} </p>
  15.             <p>{{ form.text }} </p>
  16.             <p><input type="submit" value="提交请求"></p>
  17.         </form>
  18.     </div>
  19. </body>
  20. </html>
  1. # name: models.py
  2. from django.db import models
  3.  
  4. class User(models.Model):
  5.     id = models.AutoField(primary_key=True)
  6.     username = models.CharField(max_length=64)
  7.     password = models.CharField(max_length=32)
  8.     mobile = models.CharField(max_length=32)
  9.     email = models.EmailField(max_length=64)
  10.     text = models.CharField(max_length=128)
  1. # name: views.py
  2. from django.shortcuts import render,HttpResponse
  3. from MyWeb import models
  4. from django.forms import Form,fields,widgets
  5. from django.core.validators import RegexValidator
  6. from django.core.exceptions import ValidationError
  7.  
  8. class UserForm(Form):
  9.     username = fields.CharField(
  10.         label = "账号: ",          # 给表单加一个标签
  11.         required = True,           # 不允许字段为空值
  12.         min_length=4,              # 设置最小长度
  13.         max_length = 10,           # 设置最大长度
  14.         validators=[ RegexValidator(r'^[0-9a-zA-Z]+$',"用户账号只能使用,0-9a-z") ],
  15.         error_messages={"required":"该字段不能为空","invalid":"无效的用户名",
  16.                         "min_length":"最小长度为5","max_length":"最大长度为10"},
  17.         widget=widgets.TextInput(attrs={"placeholder":"请输入用户名","class":"form-control"})
  18.     )
  19.     password = fields.CharField(
  20.         label = "密码: ",
  21.         required = True,
  22.         min_length=5,
  23.         max_length=10,
  24.         error_messages={"required":"密码字段不能为空","min_length":"密码最小长度为5"},
  25.         widget=widgets.PasswordInput(attrs={"placeholder":"请输入密码","class":"form-control"})
  26.     )
  27.     mobile = fields.CharField(
  28.         label = "手机: ",
  29.         required=True,
  30.         validators=[RegexValidator('[0-9]', "手机号必须是数字")],
  31.         error_messages={"required":"该字段不能为空"},
  32.         widget=widgets.TextInput(attrs={"placeholder": "手机号","class": "form-control"})
  33.     )
  34.     email = fields.EmailField(
  35.         label="邮箱: ",
  36.         required=True,
  37.         error_messages={"required":"邮箱不能为空！！","invalid":"无效的邮箱"},
  38.         widget=widgets.EmailInput(attrs={"placeholder": "邮箱", "class": "form-control"})
  39.     )
  40.     text = fields.CharField(
  41.         required=True,
  42.         widget=widgets.Textarea(attrs={"placeholder": "畅言,欢迎留言...", "class": "form-control",
  43.                                        "style":"margin: 0px; width: 203px; height: 98px;"})
  44.     )
  45.  
  46. def index(request):
  47.     if request.method =="GET":
  48.         form = UserForm()
  49.         return render(request, "index.html", {"form": form})
  50.     else:
  51.         form = UserForm(request.POST)
  52.         if form.is_valid():
  53.             # username = form.data['username']
  54.             data = form.cleaned_data
  55.             username = data.get("username")
  56.  
  57.             is_exits = models.User.objects.filter(username="admin").count()
  58.             if is_exits != 0:
  59.                 return HttpResponse("您注册的用户已存在")
  60.             else:
  61.                 models.User.objects.create(**data)
  62.                 return HttpResponse("恭喜您的账号注册完成了")
  63.         else:
  64.             return render(request, "index.html", {"form": form.errors})
  65.     return render(request, "index.html", {"form": form})

实现用户验证

index.html

  1. <head>
  2.     <meta charset="UTF-8">
  3.     <script src="https://code.jquery.com/jquery-3.1.1.min.js"></script>
  4. </head>
  5. <body>
  6.  
  7. <form action="/" method="post">
  8.     <p> {{ form.email }}</p>
  9.     <p> {{ form.code }} <a id="fetch_code" class="fetch-code" href="javascript:void(0);">获取验证码</a></p>
  10.     <input type="submit" value="提交">
  11. </form>
  12.  
  13.  
  14. <script type="text/javascript">
  15.     $("#fetch_code").click(function(){
  16.         var email = $("#email").val();        // 获取到用户邮箱
  17.         if(email.trim().length != 0)
  18.         {
  19.             $("#fetch_code").empty();
  20.             $("#fetch_code").text("发送成功");
  21.             $.ajax({
  22.                 url:"/send_msg/",
  23.                 type:"POST",
  24.                 data:{email:email},
  25.                 dataType:"json",
  26.                 success:function(recv){
  27.                 }
  28.             })
  29.         }
  30.     })
  31.  
  32. </script>

models.py

  1. from django.db import models
  2.  
  3. class SendMsg(models.Model):
  4.     id = models.AutoField(primary_key=True)
  5.     code = models.CharField(max_length=6)
  6.     email = models.CharField(max_length=32, db_index=True)
  7.     count = models.IntegerField(default=0)
  8.     times = models.IntegerField(default=0)
  9.  
  10. class UserInfo(models.Model):
  11.     id = models.AutoField(primary_key=True)
  12.     username = models.CharField(max_length=32, unique=True)
  13.     password = models.CharField(max_length=32)
  14.     email = models.CharField(max_length=32, unique=True)

views.py

  1. from django.shortcuts import render,HttpResponse
  2. from django.core.mail import send_mail, send_mass_mail, EmailMultiAlternatives
  3. import re,time,random
  4. from MyWeb import models
  5.  
  6. def SendMail(rand,user):
  7.     title = "本次注册验证码是: {} 十分钟以内有效.".format(rand)
  8.     ret = send_mail("Django 邮件通知",title,"smtpwho@163.com",[user])
  9.     if ret:
  10.         return 1
  11.     return 0
  12. def send_msg(request):
  13.     if request.method=="POST":
  14.         email = request.POST.get("email")
  15.         ret = re.match(r'^[0-9a-zA-Z\_\-]+(\.[0-9a-zA-Z\_\-]+)*@[0-9a-zA-Z]+(\.[0-9a-zA-Z]+){1,}$', email)
  16.         if ret == None:
  17.             print("不合法")
  18.         else:
  19.             ret = models.UserInfo.objects.filter(email=email).count()
  20.             if ret == 1:
  21.                 print("你的邮箱已经注册了,请换一个..")
  22.             else:
  23.                 ret = models.SendMsg.objects.filter(email=email).count()    # 查询出如果存在sendmsg表里,则不能让其注册
  24.                 if ret !=0:
  25.                     print("等待超时,暂时不嫩注册..")
  26.                     times = int(time.time())
  27.                     if times >=models.SendMsg.objects.filter(email=email).values("times"):
  28.                         print(times)
  29.                     else:
  30.                         print("时间还没到")
  31.  
  32.                 else:
  33.                     rand = random.randint(10000,20000)
  34.                     if SendMail(rand,email):
  35.                         times = int(time.time()+60)  # 一分钟只能注册一次
  36.                         models.SendMsg.objects.create(email=email,code=rand,times=times)
  37.     return render(request,"reg.html")
  38.  
  39. def reg(request):
  40.     if request.method == "POST":
  41.         email = request.POST.get("email")
  42.         code = request.POST.get("code")
  43.         ret = models.SendMsg.objects.filter(email=email).values("email","code")[0]
  44.         if ret['email']==email and ret['code']==code:
  45.             print("正确了")
  46.             username = request.POST.get("username")
  47.             password = request.POST.get("password")
  48.             ret = models.UserInfo.objects.filter(username=username).count()
  49.             if ret == 0:
  50.                 # 等于0说明没有这个用户,可以注册
  51.                 models.UserInfo.objects.create(username=username,password=password,email=email)
  52.                 print("注册完成了")
  53.             else:
  54.                 print("这个账号重复了,请换一个...")
  55.         else:
  56.             print("验证码错误")
  57.     return render(request, "reg.html")

urls.py

  1. from django.contrib import admin
  2. from django.urls import path
  3. from MyWeb import views
  4. urlpatterns = [
  5.     path('admin/', admin.site.urls),
  6.     path("reg/",views.reg),
  7.     path("send_msg/",views.send_msg)
  8. ]

settings.py

  1. STATIC_URL = '/static/'
  2. EMAIL_USER_TLS = True
  3. EMAIL_PORT = 25
  4. EMAIL_HOST = "smtp.163.com"
  5. EMAIL_HOST_USER = "smtpwho@163.com"
  6. EMAIL_HOST_PASSWORD = "123456789"

重写父类方法：通过form表单重写init方法,实现数据库动态添加,前端动态显示,以两个选择框为例

  1. # name: models.py
  2. from django.db import models
  3.  
  4. class DBHost(models.Model):
  5.     id = models.AutoField(primary_key=True)
  6.     host = models.CharField(max_length=32)
  7.     title = models.CharField(max_length=32)
  8.  
  9. # name:index.html
  10. {{ form.title }}
  11. {{ form.host }}
  1. # name:views.py
  2. from django.shortcuts import render
  3. from django.forms import Form,fields,widgets
  4. from MyWeb import models
  5.  
  6. class DBHost(Form):
  7.     title = fields.IntegerField(widget=widgets.Select(choices=[]))
  8.     host = fields.IntegerField(widget=widgets.SelectMultiple(choices=[]))
  9.  
  10.     # 重写父类的 __init__ 方法
  11.     def __init__(self,*args,**kwargs):
  12.         super(DBHost, self).__init__(*args,**kwargs)
  13.         self.fields['title'].widget.choices = models.DBHost.objects.all().values_list("id","title")
  14.         self.fields['host'].widget.choices = models.DBHost.objects.all().values_list("id", "host")
  15.  
  16. def index(request):
  17.     form = DBHost()
  18.     return render(request,"index.html",{"form":form})

给Form表单返回数据: Form表单可以返回默认数据,我们可以通过编号查询到指定数据的默认参数,并返回到编辑框中.

  1. # name:views.py
  2. from django.shortcuts import render
  3. from django.forms import Form,fields,widgets
  4. from MyWeb import models
  5.  
  6. class MyForm(Form):
  7.     host = fields.CharField(required=True,widget=widgets.TextInput())
  8.     title = fields.CharField(required=True, widget=widgets.TextInput())
  9.  
  10. def index(request):
  11.     nid = request.GET.get("id")   # 通过ID获取到记录
  12.     qset = models.DBHost.objects.filter(id=nid).values("host","title")
  13.     dic = qset[0]  # 转为字典
  14.  
  15.     form = MyForm(dic) # 传递到前端编辑框中
  16.     return render(request,"index.html",{"form":form})
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/73806
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号