Django之静态文件配置

以登录功能为例：

如果我们用在templates写了一个登录功能的页面，并且想使用样式，但是不能用cdn的形式，那么我们只能将bootstrap,以及jQuery的文件下到本地，不过在Django的项目中怎么导入呢？

下面一步步介绍：

  1. """
  2. 我们将html文件默认都放在templates文件夹下
  3. 我们将网站所使用的静态文件默认都放在static文件夹下
  5. 静态文件
  6.     前端已经写好了的 能够直接调用使用的文件
  7.         网站写好的js文件
  8.         网站写好的css文件
  9.         网站用到的图片文件
  10.         第三方前端框架
  11.         ...
  12.         拿来就可以直接使用的
  13. """

注意:

  1. # django默认是不会自动帮你创建static文件夹 需要你自己手动创建
  2. 一般情况下我们在static文件夹内还会做进一步的划分处理
  3.     -static
  4.       --bootstrap
  5.       --js
  6.       --css
  7.       --img
  8.     其他第三方文
  1. """
  2. 在浏览器中输入url能够看到对应的资源
  3. 是因为后端提前开设了该资源的借口
  4. 如果访问不到资源 说明后端没有开设该资源的借口
  5. """

准备：

1、新建static文件夹，并下载好的bootstrap和jQuery按照之前的教程下载并放到static文件夹中（或者是其他的静态文件）

Django进阶01 - 图1

静态文件配置

在项目配置文件settings.py中配置静态文件

方法一：在项目配置文件settings.py配置静态文件

settings.py

  1. # Static files (CSS, JavaScript, Images)
  2. # https://docs.djangoproject.com/en/1.11/howto/static-files/
  4. STATIC_URL = '/static/'      # 类似于访问静态文件的令牌，如果想要访问静态文件，就必须以static开头,我们约定俗成是static，令牌也可以不是static，看项目需求
  6. #静态文件配置
  7. STATICFILES_DIRS = [
  8.     os.path.join(BASE_DIR,"static"),   # 列表说明可以有多个
  9.     os.path.join(BASE_DIR,"static1"),
  10.     os.path.join(BASE_DIR,"static2"),
  11. ]

ps:路径问题举例:

  1. # 列如：href里的静态文件路径
  2. <link href="/static/bootstrap-3.3.7-dist/css/bootstrap.min.css" rel="stylesheet">
  3. 判断到是/static/开头，符合令牌条件，然后会到STATIC_URLS中的各个目录路径查找bootstrap-3.3.7-dist/css/bootstrap.min.css资源
  5. #如果STATIC_URLS中第一个目录没有就到第二个目录查找，依次查找下去，都没有才会报错

urls.py

  1. from django.conf.urls import url
  2. from django.contrib import admin
  3. from app01 import views
  5. urlpatterns = [
  6.     url(r'^admin/', admin.site.urls),
  7.     url(r'^login/', views.login),
  8. ]

views.py

  1. from django.shortcuts import render,HttpResponse,redirect
  3. # Create your views here.
  4. #login
  5. def login(request):
  6.     # 返回一个登录界面
  7.     return render(request,"login.html")

login.html,注意此时导入的路径直接/static/开头，不用加../回到上一级

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.     <title>Document</title>
  8.     <!-- Bootstrap3 核心 CSS 文件，本地导入 -->
  9.     <link href="/static/bootstrap-3.3.7-dist/css/bootstrap.min.css" rel="stylesheet">
  10.     <!-- jQuery文件。务必在bootstrap.min.js 之前引入 -->
  11.     <script src="/static/js/jQuery_3.5.1.js"></script>
  12.     <!-- Bootstrap3 核心 JavaScript 文件 -->
  13.     <script src="/static/bootstrap-3.3.7-dist/js/bootstrap.min.js"></script>
  15. </head>
  16. <body>
  17.     <div class="container">
  18.         <div class="row">
  19.             <div class="col-md-8 col-md-offset-2">
  20.                 <h1 class="text-center">登录界面</h1>
  21.                 <form action="" >
  22.                     <p>
  23.                         用户名: <input type="text" name="username" class="form-control">
  24.                     </p>
  25.                     <p>
  26.                         密码: <input type="password" name="password" class="form-control">
  27.                     </p>
  28.                     <input type="submit" class="btn btn-success btn-block">
  29.                 </form>
  30.             </div>
  31.         </div>
  32.     </div>
  33. </body>
  34. </html>

浏览器访问：

Django进阶01 - 图2

方法二：在settings.py配置好静态后，再在login.html文件中使用模板语法，动态导入本地静态资源（建议使用）

settings.py

  1. # Static files (CSS, JavaScript, Images)
  2. # https://docs.djangoproject.com/en/1.11/howto/static-files/
  4. STATIC_URL = '/static/'
  6. #静态文件配置
  7. STATICFILES_DIRS = [
  8.     os.path.join(BASE_DIR,"static")
  9. ]

login.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.     <title>Document</title>
  9.     <!--类似于导模块,这样html文件就能动态感知到本地静态资源的令牌，再写静态资源路径时也不用写令牌了-->
  10.     {% load static %}
  11.     <!-- Bootstrap3 核心 CSS 文件，本地导入 -->
  12.     <link href="{% static "bootstrap-3.3.7-dist/css/bootstrap.min.css" %}" rel="stylesheet">
  13.     <!-- jQuery文件。务必在bootstrap.min.js 之前引入 -->
  14.     <script src="{% static "js/jQuery_3.5.1.js" %}"></script>
  15.     <!-- Bootstrap3 核心 JavaScript 文件 -->
  16.     <script src="{% static "bootstrap-3.3.7-dist/js/bootstrap.min.js" %}"></script>
  17. </head>
  18. <body>
  19.     <div class="container">
  20.         <div class="row">
  21.             <div class="col-md-8 col-md-offset-2">
  22.                 <h1 class="text-center">登录界面</h1>
  23.                 <form action="" >
  24.                     <p>
  25.                         用户名: <input type="text" name="username" class="form-control">
  26.                     </p>
  27.                     <p>
  28.                         密码: <input type="password" name="password" class="form-control">
  29.                     </p>
  30.                     <input type="submit" class="btn btn-success btn-block">
  31.                 </form>
  32.             </div>
  33.         </div>
  34.     </div>
  35. </body>
  36. </html>

回顾知识：

  1. # form表单默认时get提交
  2. http://127.0.0.1:8000/login/?username=alias&password=123
  4. # form表单action参数
  5.     1.不写 默认朝当前所在的url提交数据
  6.     2.全写 指名道姓
  7.     3.只写后缀 /login/

注意一个前期form的method的方式改为post时要注意的情况：

改为post之后浏览器访问会出现403：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.     <title>Document</title>
  9.     <!--类似于导模块-->
  10.     {% load static %}
  11.     <!-- Bootstrap3 核心 CSS 文件，本地导入 -->
  12.     <link href="{% static "bootstrap-3.3.7-dist/css/bootstrap.min.css" %}" rel="stylesheet">
  13.     <!-- jQuery文件。务必在bootstrap.min.js 之前引入 -->
  14.     <script src="{% static "js/jQuery_3.5.1.js" %}"></script>
  15.     <!-- Bootstrap3 核心 JavaScript 文件 -->
  16.     <script src="{% static "bootstrap-3.3.7-dist/js/bootstrap.min.js" %}"></script>
  17. </head>
  18. <body>
  19.     <div class="container">
  20.         <div class="row">
  21.             <div class="col-md-8 col-md-offset-2">
  22.                 <h1 class="text-center">登录界面</h1>
  23.                 <form action="" method="post">
  24.                     <p>
  25.                         用户名: <input type="text" name="username" class="form-control">
  26.                     </p>
  27.                     <p>
  28.                         密码: <input type="password" name="password" class="form-control">
  29.                     </p>
  30.                     <input type="submit" class="btn btn-success btn-block">
  31.                 </form>
  32.             </div>
  33.         </div>
  34.     </div>
  35. </body>
  36. </html>

浏览器访问

Django进阶01 - 图3

解决方法1：

  1. # 在前期我们使用django提交post请求的时候 需要取配置文件中注释掉一行代码
  2. MIDDLEWARE = [
  3.     'django.middleware.security.SecurityMiddleware',
  4.     'django.contrib.sessions.middleware.SessionMiddleware',
  5.     'django.middleware.common.CommonMiddleware',
  6.     # 'django.middleware.csrf.CsrfViewMiddleware',
  7.     'django.contrib.auth.middleware.AuthenticationMiddleware',
  8.     'django.contrib.messages.middleware.MessageMiddleware',
  9.     'django.middleware.clickjacking.XFrameOptionsMiddleware',
  10. ]

解决方法2：在form标签下面第一行添加 {% csrf_token %}

  1. <form action="" method="post">
  2.     {% csrf_token %}
  3.     <p>
  4.       用户名: <input type="text" name="username" class="form-control">
  5.     </p>
  6.     <p>
  7.       密码: <input type="password" name="password" class="form-control">
  8.     </p>
  9.     <input type="submit" class="btn btn-success btn-block">
  10. </form>

request对象方法初识

在views.py中的视图层方法里添加一个print(request)，以Debug模式启动

Django进阶01 - 图4

request.method:返回请求方式，并且是全大写的字符串形式

示例：

urls.py

  1. from django.conf.urls import url
  2. from django.contrib import admin
  3. from app01 import views
  5. urlpatterns = [
  6.     url(r'^admin/', admin.site.urls),
  7.     url(r'^login/', views.login),
  8. ]
  10. urls.py

views.py

  1. from django.shortcuts import render,HttpResponse,redirect
  3. # Create your views here.
  4. #login
  6. def login(request):
  7.     # 返回一个登陆界面
  8.     """
  9.     get请求和post请求应该有不同的处理机制
  10.     :param request: 请求相关的数据对象 里面有很多简易的方法
  11.     :return:
  12.     """
  13.     # print(type(request.method))  # 返回请求方式 并且是全大写的字符串形式  <class 'str'>
  14.     # if request.method == 'GET':
  15.     #     print('来了 老弟')
  16.     #     return render(request,'login.html')
  17.     # elif request.method == 'POST':
  18.     #     return HttpResponse("收到了 宝贝")
  20.     if request.method == 'POST':        # 这个写法也是模板写法，可以减少复杂度
  21.         return HttpResponse("收到了 宝贝")
  22.     return render(request, 'login.html')

login.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.     <title>Document</title>
  9.     <!--类似于导模块-->
  10.     {% load static %}
  11.     <!-- Bootstrap3 核心 CSS 文件，本地导入 -->
  12.     <link href="{% static "bootstrap-3.3.7-dist/css/bootstrap.min.css" %}" rel="stylesheet">
  13.     <!-- jQuery文件。务必在bootstrap.min.js 之前引入 -->
  14.     <script src="{% static "js/jQuery_3.5.1.js" %}"></script>
  15.     <!-- Bootstrap3 核心 JavaScript 文件 -->
  16.     <script src="{% static "bootstrap-3.3.7-dist/js/bootstrap.min.js" %}"></script>
  17. </head>
  18. <body>
  19.     <div class="container">
  20.         <div class="row">
  21.             <div class="col-md-8 col-md-offset-2">
  22.                 <h1 class="text-center">登录界面</h1>
  23.                 <form action="" method="post">
  24.                     <p>
  25.                         用户名: <input type="text" name="username" class="form-control">
  26.                     </p>
  27.                     <p>
  28.                         密码: <input type="password" name="password" class="form-control">
  29.                     </p>
  30.                     <input type="submit" class="btn btn-success btn-block">
  31.                 </form>
  32.             </div>
  33.         </div>
  34.     </div>
  35. </body>
  36. </html>
  38. login.html

request.POST:获取用户提交的post请求数据（不包含文件）

request.POST.get():获取列表的最后一个元素

urls.py

  1. from django.conf.urls import url
  2. from django.contrib import admin
  3. from app01 import views
  5. urlpatterns = [
  6.     url(r'^admin/', admin.site.urls),
  7.     url(r'^login/', views.login),
  8. ]
  10. urls.py

views.py

  1. from django.shortcuts import render,HttpResponse,redirect
  3. # Create your views here.
  4. #login
  5. def login(request):
  6.     """
  7.     get请求和post请求应该有不同的处理机制，可以使用request的对象方法
  8.     :param request:请求相关的数据对象，里面有很多简易的方法
  9.     :return:
  10.     """
  11.     # print(request.method)    # request.method：返回请求方式，并且是全大写的字符串形式
  12.     if request.method == "POST":
  13.         print(request.POST)    # <QueryDict: {'username': ['alias'], 'password': ['123'], 'hobby': ['111', '222', '333']}>
  14.         username = request.POST.get("username")
  15.         print(username,type(username))   # alias <class 'str'>
  16.         hobby = request.POST.get("hobby")
  17.         print(hobby,type(hobby))     # 333 <class 'str'>
  19.         return HttpResponse("收到了宝贝")
  20.     return render(request, "login.html")

login.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.     <title>Document</title>
  9.     <!--类似于导模块-->
  10.     {% load static %}
  11.     <!-- Bootstrap3 核心 CSS 文件，本地导入 -->
  12.     <link href="{% static "bootstrap-3.3.7-dist/css/bootstrap.min.css" %}" rel="stylesheet">
  13.     <!-- jQuery文件。务必在bootstrap.min.js 之前引入 -->
  14.     <script src="{% static "js/jQuery_3.5.1.js" %}"></script>
  15.     <!-- Bootstrap3 核心 JavaScript 文件 -->
  16.     <script src="{% static "bootstrap-3.3.7-dist/js/bootstrap.min.js" %}"></script>
  17. </head>
  18. <body>
  19.     <div class="container">
  20.         <div class="row">
  21.             <div class="col-md-8 col-md-offset-2">
  22.                 <h1 class="text-center">登录界面</h1>
  23.                 <form action="" method="post">
  24.                     <p>
  25.                         用户名: <input type="text" name="username" class="form-control">
  26.                     </p>
  27.                     <p>
  28.                         密码: <input type="password" name="password" class="form-control">
  29.                     </p>
  30.                     <p>
  31.                         <input type="checkbox" name="hobby" value="111">111
  32.                         <input type="checkbox" name="hobby" value="222">222
  33.                         <input type="checkbox" name="hobby" value="333">333
  34.                     </p>
  35.                     <input type="submit" class="btn btn-success btn-block">
  36.                 </form>
  37.             </div>
  38.         </div>
  39.     </div>
  40. </body>
  41. </html>

request.POST.getlist():获取整个列表

urls.py

  1. from django.conf.urls import url
  2. from django.contrib import admin
  3. from app01 import views
  5. urlpatterns = [
  6.     url(r'^admin/', admin.site.urls),
  7.     url(r'^login/', views.login),
  8. ]

views.py

  1. from django.shortcuts import render,HttpResponse,redirect
  3. # Create your views here.
  4. #login
  5. def login(request):
  6.     """
  7.     get请求和post请求应该有不同的处理机制，可以使用request的对象方法
  8.     :param request:请求相关的数据对象，里面有很多简易的方法
  9.     :return:
  10.     """
  11.     # print(request.method)    # request.method：返回请求方式，并且是全大写的字符串形式
  12.     if request.method == "POST":
  13.         print(request.POST)    # <QueryDict: {'username': ['alias'], 'password': ['123'], 'hobby': ['111', '222', '333']}>
  14.         # username = request.POST.get("username")
  15.         # print(username,type(username))   # alias <class 'str'>
  16.         # hobby = request.POST.get("hobby")    # get只会获取列表最后一个元素
  17.         # print(hobby,type(hobby))     # 333 <class 'str'>
  18.         username = request.POST.getlist("username")  # getlist会获取整个列表
  19.         print(username, type(username))  # ['alias'] <class 'list'>
  20.         hobby = request.POST.getlist("hobby")    # getlist会获取整个列表
  21.         print(hobby, type(hobby))  # ['111', '222', '333'] <class 'list'>
  22.         """
  23.         总结：
  24.         get只会获取列表最后一个元素
  25.         """
  26.         return HttpResponse("收到了宝贝")
  27.     return render(request, "login.html")

login.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.     <title>Document</title>
  9.     <!--类似于导模块-->
  10.     {% load static %}
  11.     <!-- Bootstrap3 核心 CSS 文件，本地导入 -->
  12.     <link href="{% static "bootstrap-3.3.7-dist/css/bootstrap.min.css" %}" rel="stylesheet">
  13.     <!-- jQuery文件。务必在bootstrap.min.js 之前引入 -->
  14.     <script src="{% static "js/jQuery_3.5.1.js" %}"></script>
  15.     <!-- Bootstrap3 核心 JavaScript 文件 -->
  16.     <script src="{% static "bootstrap-3.3.7-dist/js/bootstrap.min.js" %}"></script>
  17. </head>
  18. <body>
  19.     <div class="container">
  20.         <div class="row">
  21.             <div class="col-md-8 col-md-offset-2">
  22.                 <h1 class="text-center">登录界面</h1>
  23.                 <form action="" method="post">
  24.                     <p>
  25.                         用户名: <input type="text" name="username" class="form-control">
  26.                     </p>
  27.                     <p>
  28.                         密码: <input type="password" name="password" class="form-control">
  29.                     </p>
  30.                     <p>
  31.                         <input type="checkbox" name="hobby" value="111">111
  32.                         <input type="checkbox" name="hobby" value="222">222
  33.                         <input type="checkbox" name="hobby" value="333">333
  34.                     </p>
  35.                     <input type="submit" class="btn btn-success btn-block">
  36.                 </form>
  37.             </div>
  38.         </div>
  39.     </div>
  40. </body>
  41. </html>

总结：

  1. request.method # 返回请求方式 并且是全大写的字符串形式  <class 'str'>
  2. request.POST  # 获取用户post请求提交的普通数据不包含文件
  3.     request.POST.get()  # 只获取列表最后一个元素
  4.     request.POST.getlist()  # 直接将列表取出
  5. request.GET  # 获取用户提交的get请求数据
  6.     request.GET.get()  # 只获取列表最后一个元素
  7.     request.GET.getlist()  # 直接将列表取出
  9. """
  10. get请求携带的数据是有大小限制的 大概好像只有4KB左右
  11. 而post请求则没有限制
  12. """

Django链接数据库（mysql）

Django默认使用的数据库是sqlite3

  1. # Database
  2. # https://docs.djangoproject.com/en/1.11/ref/settings/#databases
  4. DATABASES = {
  5.     'default': {
  6.         'ENGINE': 'django.db.backends.sqlite3',
  7.         'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
  8.     }
  9. }

修改数据库为mysql

1、配置文件中配置

把原有的数据库配置注释掉

  1. # Database
  2. # https://docs.djangoproject.com/en/1.11/ref/settings/#databases
  4. # 把原有的数据库配置注释掉
  5. # DATABASES = {
  6. #     'default': {
  7. #         'ENGINE': 'django.db.backends.sqlite3',
  8. #         'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
  9. #     }
  10. # }
  11. # 连接MySQL数据库
  12. DATABASES = {
  13.     'default': {
  14.         'ENGINE': 'django.db.backends.mysql',
  15.         'NAME': 'day60',    # name对应数据库的名字
  16.         'USER': 'root',
  17.         'PASSWORD': '123456',
  18.         'HOST': '127.0.0.1',
  19.         'PORT': 3306,
  20.         'CHARSET': 'utf8'
  21.     }
  22. }

2、代码声明

  1. #django默认用的是mysqldb模块链接MySQL
  2.     但是该模块的兼容性不好 需要手动改为用pymysql链接
  4. # 你需要告诉django不要用默认的mysqldb，而是用pymysql
  5. # 在项目名下的init或者任意的应用名下的init文件中书写以下代码都可以

这里我们在项目目录下的init.py文件中修改：

  1. import pymysql
  2. pymysql.install_as_MySQLdb()

Django进阶01 - 图5

ps:如果不进行第二步代码声明,会发现Django起不来了，报错如图：

Django进阶01 - 图6

Django之ORM简介

  1. """
  2. ORM. 对象关系映射
  3. 作用:能够让一个不用sql语句的小白也能够通过python 面向对象的代码简单快捷的操作数据库
  4. 不足之处:封装程度太高 有时候sql语句的效率偏低 需要你自己写SQL语句
  6. 类                                 表
  8. 对象                               记录
  10. 对象属性                            记录某个字段对应的值
  12. 需要操作应用下面的models.py文件
  13. """

1、先去应用下的models.py中书写一个类(模型类)==>表(模型表)

models.py

  1. from django.db import models
  3. # Create your models here.
  4. # 类 -- 表
  5. class User(models.Model):    # 一定要继承父类models.Model
  6.     # id int primary auto_increment
  7.     id = models.AutoField(primary_key=True,verbose_name="主键")  # 此句等同于设置id字段为主键并且自增的sql语句；
  8.     # username varchar(32)
  9.     username = models.CharField(max_length=32,verbose_name="用户名")
  10.     """
  11.     CharField必须要指定max_length参数，不写直接报错
  12. 　  verbose_name该参数是所有字段都有的 就是用来对字段的解释，加了是有好处的
  13.     """ 
  14.     # password int 
  15.     password = models.IntegerField(verbose_name="密码")

2、数据库迁移命令（特别重要）

注意：在models.py里写完是没办法直接生效的，需要告诉ORM，要把上面models.py中的操作基于ORM映射到数据库里面去

两条命令：

  1. #*************************# 2 数据库迁移命令*************************
  2. python3 manage.py makemigrations 将操作记录记录到小本本上(就是应用中的migrations文件夹)
  4. python3 manage.py migrate  将操作真正的同步到数据库中
  5. # 只要你修改了models.py中跟数据库相关的代码 就必须重新执行上述的两条命令
  6. #******************************************************************

点击pycharm的terminal终端，在终端里面输入这两条数据库迁移命令

  1. # python3 manage.py makemigrations 将操作记录记录到小本本上(就是应用中的migrations文件夹)

Django进阶01 - 图7

Django进阶01 - 图8

  1. # python3 manage.py migrate  将操作真正的同步到数据库中

Django进阶01 - 图9

执行完之后再查看数据库（记得刷新之后再查看）

Django进阶01 - 图10

表解释：

Django进阶01 - 图11

  1. # app01_user表：就是我们通过ORM创建的表
  3. #ps:
  4. 为什么会自动加个前缀app01呢？
  5. 因为一个Django项目可以有多个应用，那么多个应用之间可能会出现表名冲突的情况，加上前缀就可以完全避免，比较人性化

点开app01_user表看一看：

Django进阶01 - 图12

补充：

1、

  1. # 由于一张表中必须要有一个主键字段 并且一般情况下都叫id字段
  2. # 所以orm当你不定义主键字段的时候 orm会自动帮你创建一个名为id主键字段
  3. # 也就意味着 后续我们在创建模型表的时候如果主键字段名没有额外的叫法 那么主键字段可以省略不写

所以我们再models.py里面可以这么写：

  1. class Author(models.Model):
  2.     # username varchar(32)
  3.     username = models.CharField(max_length=32，verbose_name='用户名')
  4.     # password int
  5.     password = models.IntegerField(verbose_name='密码')
  6.     """
  7.     CharField必须要指定max_length参数 不指定会直接报错
  8.     verbose_name该参数是所有字段都有的 就是用来对字段的解释
  9.     """

2、数据库迁移命令，也可以在Tools-Run manage.py Task…里面写

Django进阶01 - 图13

不用写python3 manage.py，直接写命令（前期不建议使用）

如下：

  1. # makemigrations   将操作记录记录到小本本上（应用下migrations文件夹中）
  3. # migrate     将操作真正同步到数据库中

利用ORM实现数据的增删改查操作

字段的增删改查

先看一下环境：

user数据库：

Django进阶01 - 图14

models.py

  1. from django.db import models
  3. # Create your models here.
  4. # 类 -- 表
  5. class User(models.Model):    # 一定要继承父类models.Model
  6.     # id int primary auto_increment
  7.     id = models.AutoField(primary_key=True,verbose_name="主键")  # 此句等同于设置id字段为主键并且自增的sql语句；
  8.     # username varchar(32)
  9.     username = models.CharField(max_length=32,verbose_name="用户名")
  10.     """
  11.     CharField必须要指定max_length参数，不写直接报错
  12.     """
  13.     # password int
  14.     password = models.IntegerField(verbose_name="密码")

增字段

直接在models.py中的类的相应位置添加字段就可以，例如给user数据库添加一个age字段

表中已经有数据，添加字段第一种处理方法：执行# python3 manage.py makemigrations时出现选项后选1，立即给一个默认值

models.py

  1. from django.db import models
  3. # Create your models here.
  4. # 类 -- 表
  5. class User(models.Model):    # 一定要继承父类models.Model
  6.     # id int primary auto_increment
  7.     id = models.AutoField(primary_key=True,verbose_name="主键")  # 此句等同于设置id字段为主键并且自增的sql语句；
  8.     # username varchar(32)
  9.     username = models.CharField(max_length=32,verbose_name="用户名")
  10.     """
  11.     CharField必须要指定max_length参数，不写直接报错
  12.     """
  13.     # password int
  14.     password = models.IntegerField(verbose_name="密码")
  15.     age = models.IntegerField(verbose_name="年龄")

因为修改了跟数据库相关的代码，得执行一下数据库迁移命令：

  1. # python manage.py makemigrations     # 注意：会有提示，这是因为user表中已经有数据

Django进阶01 - 图15

第一个选项：立刻给他设置一个默认值

第二个选项：离开之后手动给他添加一个默认值

Django进阶01 - 图16

Django进阶01 - 图17

  1. # python3 manage.py migrate

表中已经有数据，添加字段第二种处理方法：在models.py的类中添加字段时，设置字段可以为空

models.py

  1. from django.db import models
  3. # Create your models here.
  4. # 类 -- 表
  5. class User(models.Model):    # 一定要继承父类models.Model
  6.     # id int primary auto_increment
  7.     id = models.AutoField(primary_key=True,verbose_name="主键")  # 此句等同于设置id字段为主键并且自增的sql语句；
  8.     # username varchar(32)
  9.     username = models.CharField(max_length=32,verbose_name="用户名")
  10.     """
  11.     CharField必须要指定max_length参数，不写直接报错
  12.     """
  13.     # password int
  14.     password = models.IntegerField(verbose_name="密码")
  15.     age = models.IntegerField(verbose_name="年龄")
  16.     # null=True字段可以为空
  17.     info = models.CharField(max_length=32,verbose_name="个人简介",null=True)

此时执行数据库迁移命令，就不会出现选项了。

Django进阶01 - 图18

Django进阶01 - 图19

表中已经有数据，添加字段第三种处理方法：在models.py的类中添加字段时，直接给默认值

models.py

  1. from django.db import models
  3. # Create your models here.
  4. # 类 -- 表
  5. class User(models.Model):    # 一定要继承父类models.Model
  6.     # id int primary auto_increment
  7.     id = models.AutoField(primary_key=True,verbose_name="主键")  # 此句等同于设置id字段为主键并且自增的sql语句；
  8.     # username varchar(32)
  9.     username = models.CharField(max_length=32,verbose_name="用户名")
  10.     """
  11.     CharField必须要指定max_length参数，不写直接报错
  12.     """
  13.     # password int
  14.     password = models.IntegerField(verbose_name="密码")
  15.     age = models.IntegerField(verbose_name="年龄")
  16.     # null=True字段可以为空
  17.     info = models.CharField(max_length=32,verbose_name="个人简介",null=True)
  18.     # default直接给字段设置默认值
  19.     hobby = models.CharField(max_length=32,verbose_name="兴趣爱好",default="study")

执行数据库迁移命令

Django进阶01 - 图20

Django进阶01 - 图21

修改字段:直接修改代码然后执行数据库迁移的两条命令即可

修改前的password字段类型

Django进阶01 - 图22

例如：我要把password的字段类型改成varchar类型

  1. from django.db import models
  3. # Create your models here.
  4. # 类 -- 表
  5. class User(models.Model):    # 一定要继承父类models.Model
  6.     # id int primary auto_increment
  7.     id = models.AutoField(primary_key=True,verbose_name="主键")  # 此句等同于设置id字段为主键并且自增的sql语句；
  8.     # username varchar(32)
  9.     username = models.CharField(max_length=32,verbose_name="用户名")
  11.     # password = models.IntegerField(verbose_name="密码")   #原先的
  12.     password = models.CharField(max_length=32,verbose_name="密码")  #修改后的
  13.     age = models.IntegerField(verbose_name="年龄")
  14.     # null=True字段可以为空
  15.     info = models.CharField(max_length=32,verbose_name="个人简介",null=True)
  16.     # default直接给字段设置默认值
  17.     hobby = models.CharField(max_length=32,verbose_name="兴趣爱好",default="study")

执行数据库迁移命令

  1. # python3 manage.py makemigrations
  3. # python3 manage.py migrate

修改后查看password类型

Django进阶01 - 图23

字段的删除：把想删除的字段注释掉，然后再执行数据库迁移的两条命令即可（执行完毕之后字段对应的数据也都没有了）

比如说我想删除age，info以及hobby字段

models.py

  1. from django.db import models
  3. # Create your models here.
  4. # 类 -- 表
  5. class User(models.Model):    # 一定要继承父类models.Model
  6.     # id int primary auto_increment
  7.     id = models.AutoField(primary_key=True,verbose_name="主键")  # 此句等同于设置id字段为主键并且自增的sql语句；
  8.     # username varchar(32)
  9.     username = models.CharField(max_length=32,verbose_name="用户名")
  10.     """
  11.     CharField必须要指定max_length参数，不写直接报错
  12.     """
  13.     # password int
  14.     # password = models.IntegerField(verbose_name="密码")   #原先的
  15.     password = models.CharField(max_length=32,verbose_name="密码")  #修改后的
  16.     # age = models.IntegerField(verbose_name="年龄")
  17.     # # null=True字段可以为空
  18.     # info = models.CharField(max_length=32,verbose_name="个人简介",null=True)
  19.     # # default直接给字段设置默认值
  20.     # hobby = models.CharField(max_length=32,verbose_name="兴趣爱好",default="study")

数据库迁移

  1. # python3 manage.py makemigrations
  3. # python3 manage.py migrate

查看

Django进阶01 - 图24

总结：

  1. """
  2. 在操作models.py的时候一定要细心
  3.     注释一些字段千万要小心，因为注释后执行迁移命令，字段对应的数据就都没了
  4.     执行迁移命令之前最好先检查一下自己写的代码
  5. """
  7. # 个人建议:当你离开你的计算机之后一定要锁屏

数据的增删改查:

看一下环境：

数据库：

Django进阶01 - 图25

查询数据：

查单条数据：models.User.objects.filter(条件)

views.py

  1. from django.shortcuts import render,HttpResponse,redirect
  2. from app01 import models    # orm查询数据要依靠这个
  4. # Create your views here.
  5. #login
  6. def login(request):
  7.     """
  8.     get请求和post请求应该有不同的处理机制，可以使用request的对象方法
  9.     :param request:请求相关的数据对象，里面有很多简易的方法
  10.     :return:
  11.     """
  12.     # print(request.method)    # request.method：返回请求方式，并且是全大写的字符串形式
  13.     if request.method == "POST":
  14.         #获取用户的用户名和密码 然后利用orm操作数据 校验数据是否正确
  15.         username = request.POST.get("username")
  16.         password = request.POST.get("password")
  18.         # 去数据库中查询数据
  19.         # select * from user where username='egon';   可以把filter联想成where记忆
  20.         user_obj = models.User.objects.filter(username=username).first()     #拿到列表里的第一个元素
  21. 　　　   # ps:filter()里面可以跟多个参数，用逗号隔开,参数之间是and关系
  22.         # user_obj = models.User.objects.filter(username=username,password=password).first()   #select * from user where username='egon' and password = 'xxx';
  23.         # ===============还可以使用索引取值====================
  24.         # user_obj = models.User.objects.filter(username=username)
  25.         # # print(user_obj)默认打印<QuerySet [<User: User object>]> 类似于列表套数据对象，[数据对象1，数据对象2],它也支持索引取值，切片操作，注意不支持负数
  26.         # print(user_obj)     # 在models.py的对应添加__str__方法后，打印的是<QuerySet [<User: alias>]>
  27.         # user_obj = res[0]   # 但是并不推荐使用索引取值,使用models.User.objects.filter(username=username).first()
  28.         # print(user_obj.username)   # egon
  29.         # print(user_obj.password)   # 123
  30.         # =================================
  31.         if user_obj:
  32.             # 比对密码是否一致
  33.             if password == user_obj.password:
  34.                 return HttpResponse("登录成功")
  35.             else:
  36.                 return HttpResponse("密码错误")
  37.         else:
  38.             return HttpResponse("用户不存在")
  40.     return render(request, "login.html")

models.py

  1. from django.db import models
  3. # Create your models here.
  4. # 类 -- 表
  5. class User(models.Model):    # 一定要继承父类models.Model
  6.     # id int primary auto_increment
  7.     id = models.AutoField(primary_key=True,verbose_name="主键")  # 此句等同于设置id字段为主键并且自增的sql语句；
  8.     # username varchar(32)
  9.     username = models.CharField(max_length=32,verbose_name="用户名")
  10.     """
  11.     CharField必须要指定max_length参数，不写直接报错
  12.     """
  13.     # password int
  14.     # password = models.IntegerField(verbose_name="密码")   #原先的
  15.     password = models.CharField(max_length=32,verbose_name="密码")  #修改后的
  16.     # age = models.IntegerField(verbose_name="年龄")
  17.     # # null=True字段可以为空
  18.     # info = models.CharField(max_length=32,verbose_name="个人简介",null=True)
  19.     # # default直接给字段设置默认值
  20.     # hobby = models.CharField(max_length=32,verbose_name="兴趣爱好",default="study")
  22.     def __str__(self):    #当对象被打印的时候，会触发这个方法
  23.         return "%s" %self.username

查多条数据：select * from xxx

现有记录：

Django进阶01 - 图26

方式一：filter()括号内不加条件

urls.py

  1. from django.conf.urls import url
  2. from django.contrib import admin
  3. from app01 import views
  5. urlpatterns = [
  6.     url(r'^admin/', admin.site.urls),
  7.     # 登录功能
  8.     url(r'^login/', views.login),
  9.     # 注册功能
  10.     url(r'^register/', views.register),
  11.     # 展示功能
  12.     url(r'^userlist/', views.userlist),
  13. ]

views.py

  1. from django.shortcuts import render,HttpResponse,redirect
  2. from app01 import models  # orm查询数据要依靠这个
  4. # Create your views here.
  5. #login
  6. def login(request):
  7.     """
  8.     get请求和post请求应该有不同的处理机制，可以使用request的对象方法
  9.     :param request:请求相关的数据对象，里面有很多简易的方法
  10.     :return:
  11.     """
  12.     # print(request.method)    # request.method：返回请求方式，并且是全大写的字符串形式
  13.     if request.method == "POST":
  14.         #获取用户的用户名和密码 然后利用orm操作数据 校验数据是否正确
  15.         username = request.POST.get("username")
  16.         password = request.POST.get("password")
  17.         # 去数据库中查询数据
  18.         # select * from user where username='egon';
  19.         user_obj = models.User.objects.filter(username=username).first()     #拿到列表里的第一个元素
  20.         # ===============还可以使用索引取值====================
  21.         # user_obj = models.User.objects.filter(username=username)
  22.         # # print(user_obj)默认打印<QuerySet [<User: User object>]> 类似于列表套数据对象，[数据对象1，数据对象2],它也支持索引取值，切片操作，注意不支持负数
  23.         # print(user_obj)     # 在models.py的对应添加__str__方法后，打印的是<QuerySet [<User: alias>]>
  24.         # user_obj = res[0]   # 但是并不推荐使用索引取值,使用models.User.objects.filter(username=username).first()
  25.         # print(user_obj.username)   # egon
  26.         # print(user_obj.password)   # 123
  27.         # =================================
  28.         if user_obj:
  29.             # 比对密码是否一致
  30.             if password == user_obj.password:
  31.                 return HttpResponse("登录成功")
  32.             else:
  33.                 return HttpResponse("密码错误")
  34.         else:
  35.             return HttpResponse("用户不存在")
  37.     return render(request, "login.html")
  39. #注册
  40. def register(request):
  41.     if request.method == "POST":
  42.         username = request.POST.get("username")
  43.         password = request.POST.get("password")
  44.         user_obj = models.User.objects.filter(username=username).first()
  45.         if user_obj:
  46.             return HttpResponse("用户已经存在")
  47.         # 直接获取用户数据存入数据库
  48.         user_obj = models.User(username=username,password=password)
  49.         user_obj.save()  #保存数据
  50.     # 先给用户返回一个注册页面
  51.     return render(request,"register.html")
  53. # 展示功能
  54. def userlist(request):
  55.     # 查询出用户表里面所有的数据
  56.     # 方式一：
  57.     data = models.User.objects.filter()
  58.     print(data)   # <QuerySet [<User: egon>, <User: tank>, <User: alias>, <User: wangpeng>, <User: jc>]>
  59.     # 因为在models.py中加了__str__方法，否则默认显示为<QuerySet [<User: User object>, <User: User object>, <User: User object>, <User: User object>, <User: User object>]>
  61.     return HttpResponse("userlist")

models.py

  1. from django.db import models
  3. # Create your models here.
  4. # 类 -- 表
  5. class User(models.Model):    # 一定要继承父类models.Model
  6.     # id int primary auto_increment
  7.     id = models.AutoField(primary_key=True,verbose_name="主键")  # 此句等同于设置id字段为主键并且自增的sql语句；
  8.     # username varchar(32)
  9.     username = models.CharField(max_length=32,verbose_name="用户名")
  10.     password = models.CharField(max_length=32,verbose_name="密码")  #修改后的
  12.     def __str__(self):    #当对象被打印的时候，会触发这个方法
  13.         return "%s" %self.username

方法二：models.User.objects.all() 推荐方式

urls.py

  1. from django.conf.urls import url
  2. from django.contrib import admin
  3. from app01 import views
  5. urlpatterns = [
  6.     url(r'^admin/', admin.site.urls),
  7.     # 登录功能
  8.     url(r'^login/', views.login),
  9.     # 注册功能
  10.     url(r'^register/', views.register),
  11.     # 展示功能
  12.     url(r'^userlist/', views.userlist),
  13. ]

views.py

  1. from django.shortcuts import render,HttpResponse,redirect
  2. from app01 import models  # orm查询数据要依靠这个
  4. # Create your views here.
  5. #login
  6. def login(request):
  7.     """
  8.     get请求和post请求应该有不同的处理机制，可以使用request的对象方法
  9.     :param request:请求相关的数据对象，里面有很多简易的方法
  10.     :return:
  11.     """
  12.     # print(request.method)    # request.method：返回请求方式，并且是全大写的字符串形式
  13.     if request.method == "POST":
  14.         #获取用户的用户名和密码 然后利用orm操作数据 校验数据是否正确
  15.         username = request.POST.get("username")
  16.         password = request.POST.get("password")
  17.         # 去数据库中查询数据
  18.         # select * from user where username='egon';
  19.         user_obj = models.User.objects.filter(username=username).first()     #拿到列表里的第一个元素
  20.         # ===============还可以使用索引取值====================
  21.         # user_obj = models.User.objects.filter(username=username)
  22.         # # print(user_obj)默认打印<QuerySet [<User: User object>]> 类似于列表套数据对象，[数据对象1，数据对象2],它也支持索引取值，切片操作，注意不支持负数
  23.         # print(user_obj)     # 在models.py的对应添加__str__方法后，打印的是<QuerySet [<User: alias>]>
  24.         # user_obj = res[0]   # 但是并不推荐使用索引取值,使用models.User.objects.filter(username=username).first()
  25.         # print(user_obj.username)   # egon
  26.         # print(user_obj.password)   # 123
  27.         # =================================
  28.         if user_obj:
  29.             # 比对密码是否一致
  30.             if password == user_obj.password:
  31.                 return HttpResponse("登录成功")
  32.             else:
  33.                 return HttpResponse("密码错误")
  34.         else:
  35.             return HttpResponse("用户不存在")
  37.     return render(request, "login.html")
  39. #注册
  40. def register(request):
  41.     if request.method == "POST":
  42.         username = request.POST.get("username")
  43.         password = request.POST.get("password")
  44.         user_obj = models.User.objects.filter(username=username).first()
  45.         if user_obj:
  46.             return HttpResponse("用户已经存在")
  47.         # 直接获取用户数据存入数据库
  48.         user_obj = models.User(username=username,password=password)
  49.         user_obj.save()  #保存数据
  50.     # 先给用户返回一个注册页面
  51.     return render(request,"register.html")
  53. # 展示功能
  54. def userlist(request):
  55.     # 查询出用户表里面所有的数据
  56.     # 方式二：
  57.     data = models.User.objects.all()
  58.     print(data)   # <QuerySet [<User: egon>, <User: tank>, <User: alias>, <User: wangpeng>, <User: jc>]>
  59.     # 因为在models.py中加了__str__方法，否则默认显示为<QuerySet [<User: User object>, <User: User object>, <User: User object>, <User: User object>, <User: User object>]>
  61.     return HttpResponse("userlist")

models.py

  1. from django.db import models
  3. # Create your models here.
  4. # 类 -- 表
  5. class User(models.Model):    # 一定要继承父类models.Model
  6.     # id int primary auto_increment
  7.     id = models.AutoField(primary_key=True,verbose_name="主键")  # 此句等同于设置id字段为主键并且自增的sql语句；
  8.     # username varchar(32)
  9.     username = models.CharField(max_length=32,verbose_name="用户名")
  10.     password = models.CharField(max_length=32,verbose_name="密码")  #修改后的
  12.     def __str__(self):    #当对象被打印的时候，会触发这个方法
  13.         return "%s" %self.username

数据的增加:

增的方法一：models.User.objects.create()

urls.py

  1. from django.conf.urls import url
  2. from django.contrib import admin
  3. from app01 import views
  5. urlpatterns = [
  6.     url(r'^admin/', admin.site.urls),
  7.     url(r'^login/', views.login),
  8.     url(r'^register/', views.register),
  9. ]

views.py

  1. from django.shortcuts import render,HttpResponse,redirect
  2. from app01 import models  # orm查询数据要依靠这个
  4. # Create your views here.
  5. #login
  6. def login(request):
  7.     """
  8.     get请求和post请求应该有不同的处理机制，可以使用request的对象方法
  9.     :param request:请求相关的数据对象，里面有很多简易的方法
  10.     :return:
  11.     """
  12.     # print(request.method)    # request.method：返回请求方式，并且是全大写的字符串形式
  13.     if request.method == "POST":
  14.         #获取用户的用户名和密码 然后利用orm操作数据 校验数据是否正确
  15.         username = request.POST.get("username")
  16.         password = request.POST.get("password")
  17.         from app01 import models  # orm查询数据要依靠这个
  18.         # 去数据库中查询数据
  19.         # select * from user where username='egon';
  20.         user_obj = models.User.objects.filter(username=username).first()     #拿到列表里的第一个元素
  21.         # ===============还可以使用索引取值====================
  22.         # user_obj = models.User.objects.filter(username=username)
  23.         # # print(user_obj)默认打印<QuerySet [<User: User object>]> 类似于列表套数据对象，[数据对象1，数据对象2],它也支持索引取值，切片操作，注意不支持负数
  24.         # print(user_obj)     # 在models.py的对应添加__str__方法后，打印的是<QuerySet [<User: alias>]>
  25.         # user_obj = res[0]   # 但是并不推荐使用索引取值,使用models.User.objects.filter(username=username).first()
  26.         # print(user_obj.username)   # egon
  27.         # print(user_obj.password)   # 123
  28.         # =================================
  29.         if user_obj:
  30.             # 比对密码是否一致
  31.             if password == user_obj.password:
  32.                 return HttpResponse("登录成功")
  33.             else:
  34.                 return HttpResponse("密码错误")
  35.         else:
  36.             return HttpResponse("用户不存在")
  38.     return render(request, "login.html")
  40. #注册
  41. def register(request):
  42.     if request.method == "POST":
  43.         username = request.POST.get("username")
  44.         password = request.POST.get("password")
  46.         user_obj = models.User.objects.filter(username=username).first()
  47.         if user_obj:
  48.             return HttpResponse("用户已经存在")
  49.         # 直接获取用户数据存入数据库
  50.         res = models.User.objects.create(username=username,password=password)
  51.         # res返回值就是当前被创建的对象本身
  52.         print(res)  # alias,这是个对象，打印这个是因为之前在models.py对应的类里添加l__str__方法
  53.     # 先给用户返回一个注册页面
  54.     return render(request,"register.html")

models.py

  1. from django.db import models
  3. # Create your models here.
  4. # 类 -- 表
  5. class User(models.Model):    # 一定要继承父类models.Model
  6.     # id int primary auto_increment
  7.     id = models.AutoField(primary_key=True,verbose_name="主键")  # 此句等同于设置id字段为主键并且自增的sql语句；
  8.     # username varchar(32)
  9.     username = models.CharField(max_length=32,verbose_name="用户名")
  10.     """
  11.     CharField必须要指定max_length参数，不写直接报错
  12.     """
  13.     # password int
  14.     # password = models.IntegerField(verbose_name="密码")   #原先的
  15.     password = models.CharField(max_length=32,verbose_name="密码")  #修改后的
  16.     # age = models.IntegerField(verbose_name="年龄")
  17.     # # null=True字段可以为空
  18.     # info = models.CharField(max_length=32,verbose_name="个人简介",null=True)
  19.     # # default直接给字段设置默认值
  20.     # hobby = models.CharField(max_length=32,verbose_name="兴趣爱好",default="study")
  22.     def __str__(self):    #当对象被打印的时候，会触发这个方法
  23.         return "%s" %self.username

增的方式二：实例化类

views.py

  1. from django.shortcuts import render,HttpResponse,redirect
  2. from app01 import models  # orm查询数据要依靠这个
  4. # Create your views here.
  5. #login
  6. def login(request):
  7.     """
  8.     get请求和post请求应该有不同的处理机制，可以使用request的对象方法
  9.     :param request:请求相关的数据对象，里面有很多简易的方法
  10.     :return:
  11.     """
  12.     # print(request.method)    # request.method：返回请求方式，并且是全大写的字符串形式
  13.     if request.method == "POST":
  14.         #获取用户的用户名和密码 然后利用orm操作数据 校验数据是否正确
  15.         username = request.POST.get("username")
  16.         password = request.POST.get("password")
  17.         from app01 import models  # orm查询数据要依靠这个
  18.         # 去数据库中查询数据
  19.         # select * from user where username='egon';
  20.         user_obj = models.User.objects.filter(username=username).first()     #拿到列表里的第一个元素(推荐使用这种方法)
  21.         # ===============还可以使用索引取值====================
  22.         # user_obj = models.User.objects.filter(username=username)
  23.         # # print(user_obj)默认打印<QuerySet [<User: User object>]> 类似于列表套数据对象，[数据对象1，数据对象2],它也支持索引取值，切片操作，注意不支持负数
  24.         # print(user_obj)     # 在models.py的对应添加__str__方法后，打印的是<QuerySet [<User: alias>]>
  25.         # user_obj = res[0]   # 但是并不推荐使用索引取值,使用models.User.objects.filter(username=username).first()
  26.         # print(user_obj.username)   # egon
  27.         # print(user_obj.password)   # 123
  28.         # =================================
  29.         if user_obj:
  30.             # 比对密码是否一致
  31.             if password == user_obj.password:
  32.                 return HttpResponse("登录成功")
  33.             else:
  34.                 return HttpResponse("密码错误")
  35.         else:
  36.             return HttpResponse("用户不存在")
  38.     return render(request, "login.html")
  40. #注册
  41. def register(request):
  42.     if request.method == "POST":
  43.         username = request.POST.get("username")
  44.         password = request.POST.get("password")
  45.         user_obj = models.User.objects.filter(username=username).first()
  46.         if user_obj:
  47.             return HttpResponse("用户已经存在")
  48.         # 实例化类
  49.         user_obj = models.User(username=username,password=password)
  50.         user_obj.save()  #保存数据
  51.     # 先给用户返回一个注册页面
  52.     return render(request,"register.html")

models.py

  1. from django.db import models
  3. # Create your models here.
  4. # 类 -- 表
  5. class User(models.Model):    # 一定要继承父类models.Model
  6.     # id int primary auto_increment
  7.     id = models.AutoField(primary_key=True,verbose_name="主键")  # 此句等同于设置id字段为主键并且自增的sql语句；
  8.     # username varchar(32)
  9.     username = models.CharField(max_length=32,verbose_name="用户名")
  10.     """
  11.     CharField必须要指定max_length参数，不写直接报错
  12.     """
  13.     # password int
  14.     # password = models.IntegerField(verbose_name="密码")   #原先的
  15.     password = models.CharField(max_length=32,verbose_name="密码")  #修改后的
  16.     # age = models.IntegerField(verbose_name="年龄")
  17.     # # null=True字段可以为空
  18.     # info = models.CharField(max_length=32,verbose_name="个人简介",null=True)
  19.     # # default直接给字段设置默认值
  20.     # hobby = models.CharField(max_length=32,verbose_name="兴趣爱好",default="study")
  22.     def __str__(self):    #当对象被打印的时候，会触发这个方法
  23.         return "%s" %self.username

数据的修改

  1. # 后端查询出用户想要编辑的数据对象 展示到前端页面供用户查看和编辑
  2.   def edit_user(request):
  3.     # 获取url问号后面的参数
  4.     edit_id = request.GET.get('user_id')
  5.     # 查询当前用户想要编辑的数据对象
  6.     edit_obj = models.User.objects.filter(id=edit_id).first()
  8.     if request.method == "POST":
  9.         username = request.POST.get('username')
  10.         password = request.POST.get('password')
  11.         # 去数据库中修改对应的数据内容
  12.         # 修改数据方式1
  13.         # models.User.objects.filter(id=edit_id).update(username=username,password=password)
  14.         """
  15.             将filter查询出来的列表中所有的对象全部更新            批量更新操作，取决于filter(条件)查找到的对象个数
  16.             只修改被修改的字段
  17.         """
  19.         # 修改数据方式2，通过对象赋值，再save()，这是单个更新
  20.         edit_obj.username = username
  21.         edit_obj.password= password
  22.         edit_obj.save()
  23.         """
  24.             方法2当字段特别多的时候效率会非常的低
  25.             从头到尾将数据的所有字段全部更新一边 无论该字段是否被修改
  26.         """
  28.         # 跳转到数据的展示页面
  29.         return redirect('/userlist/')
  33.     # 将数据对象展示到页面上
  34.     return render(request,'edit_user.html',locals())

数据的删除

  1. # 删除功能
  3. # 跟编辑功能逻辑类似
  4. def delete_user(request):
  5.     # 获取用户想要删除的数据id值
  6.     delete_id = request.GET.get('user_id')
  7.     # 直接去数据库中找到对应的数据删除即可
  8.     models.User.objects.filter(id=delete_id).delete()
  9.     """
  10.         批量删除
  11.     """    """       方法二：通过对象删除,单个删除       user_obj = models.User.objects.filter(id=delete_id).first()       user_obj.delete()    """
  12.     # 跳转到展示页面
  14.     return redirect('/userlist/')

示例：

功能描述：将用户信息在前端展示给用户，供用户编辑或删除，

urls.py

  1. from django.conf.urls import url
  2. from django.contrib import admin
  3. from app01 import views
  5. urlpatterns = [
  6.     url(r'^admin/', admin.site.urls),
  7.     # 登录功能
  8.     url(r'^login/', views.login),
  9.     # 注册功能
  10.     url(r'^register/', views.register),
  11.     # 展示功能
  12.     url(r'^userlist/', views.userlist),
  13.     # 编辑用户
  14.     url(r'^edit_user/', views.edit_user),
  15.     # 删除用户
  16.     url(r'^delete_user/', views.delete_user),
  17. ]

views.py

  1. from django.shortcuts import render,HttpResponse,redirect
  2. from app01 import models  # orm查询数据要依靠这个
  4. # Create your views here.
  5. #login
  6. def login(request):
  8.     # print(request.method)    # request.method：返回请求方式，并且是全大写的字符串形式
  9.     if request.method == "POST":
  10.         #获取用户的用户名和密码 然后利用orm操作数据 校验数据是否正确
  11.         username = request.POST.get("username")
  12.         password = request.POST.get("password")
  13.         # 去数据库中查询数据
  14.         # select * from user where username='egon';
  15.         user_obj = models.User.objects.filter(username=username).first()     #拿到列表里的第一个元素
  17.         if user_obj:
  18.             # 比对密码是否一致
  19.             if password == user_obj.password:
  20.                 return HttpResponse("登录成功")
  21.             else:
  22.                 return HttpResponse("密码错误")
  23.         else:
  24.             return HttpResponse("用户不存在")
  26.     return render(request, "login.html")
  28. #注册
  29. def register(request):
  30.     if request.method == "POST":
  31.         username = request.POST.get("username")
  32.         password = request.POST.get("password")
  33.         user_obj = models.User.objects.filter(username=username).first()
  34.         if user_obj:
  35.             return HttpResponse("用户已经存在")
  36.         # 直接获取用户数据存入数据库
  37.         user_obj = models.User(username=username,password=password)
  38.         user_obj.save()  #保存数据
  39.     # 先给用户返回一个注册页面
  40.     return render(request,"register.html")
  42. # 展示功能
  43. def userlist(request):
  44.     # 查询出用户表里面所有的数据
  45.     user_queryset = models.User.objects.all()
  46.     # print(user_queryset)   # <QuerySet [<User: egon>, <User: tank>, <User: alias>, <User: wangpeng>, <User: jc>]>
  47.     # 因为在models.py中加了__str__方法，否则默认显示为<QuerySet [<User: User object>, <User: User object>, <User: User object>, <User: User object>, <User: User object>]>
  49.     return render(request,'userlist.html',{"user_queryset":user_queryset})
  51. # 编辑用户
  52. def edit_user(request):
  53.     # 接收前端发过来的user_id
  54.     edit_id = request.GET.get("user_id")
  56.     # 获取提交过来的用户名和密码
  57.     if request.method == "POST":
  58.         username = request.POST.get("username")
  59.         password = request.POST.get("password")
  60.         # 去数据库中修改对应的数据内容
  61.         models.User.objects.filter(id=edit_id).update(username=username,password=password)
  62.         """
  63.         将filter查询出来的列表中所有的对象全部更新    批量更新操作
  64.         """
  65.         return redirect("/userlist/")
  67.     # 查询出想要编辑的用户信息,展示到前端供用户编辑
  68.     edit_obj = models.User.objects.filter(id=edit_id).first()
  69.     #将数据对象展示到页面上
  70.     return render(request,"edit_user.html",{"edit_obj":edit_obj})
  72. # 删除用户
  73. def delete_user(request):
  74.     # 接收前端发过来的user_id
  75.     delete_id = request.GET.get("user_id")
  77.     #直接去数据库中找到对应的数据删除
  78.     models.User.objects.filter(id=delete_id).delete()
  79.     """
  80.     批量删除
  81.     """
  82.     return redirect("/userlist/")

userlist.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.     <title>Document</title>
  9.     <!--类似于导模块-->
  10.     {% load static %}
  11.     <!-- Bootstrap3 核心 CSS 文件，本地导入 -->
  12.     <link href="{% static "bootstrap-3.3.7-dist/css/bootstrap.min.css" %}" rel="stylesheet">
  13.     <!-- jQuery文件。务必在bootstrap.min.js 之前引入 -->
  14.     <script src="{% static "js/jQuery_3.5.1.js" %}"></script>
  15.     <!-- Bootstrap3 核心 JavaScript 文件 -->
  16.     <script src="{% static "bootstrap-3.3.7-dist/js/bootstrap.min.js" %}"></script>
  17. </head>
  18. <body>
  19.     <div class="container">
  20.         <div class="row">
  21.             <div class="col-md-8 col-md-offset-2">
  22.                 <h1 class="text-center">数据展示</h1>
  23.                 <table class="table table-striped table-hover">
  24.                     <thead>
  25.                         <tr>
  26.                             <th>id</th>
  27.                             <th>username</th>
  28.                             <th>password</th>
  29.                             <th>action</th>
  30.                         </tr>
  31.                     </thead>
  32.                     {% for user_obj in user_queryset %}
  33.                         <tr>
  34.                             <td>{{ user_obj.id }}</td>
  35.                             <td>{{ user_obj.username }}</td>
  36.                             <td>{{ user_obj.password }}</td>
  37.                             <td>
  38.                                 <!--用户点了编辑之后，通过?后面跟k，v的方法将编辑的用户id发送给后端;/edit_user/?user_id={{ user_obj.id }}-->
  39.                                 <a href="/edit_user/?user_id={{ user_obj.id }}" class="btn btn-primary btn-xs">编辑</a>
  40.                                 <a href="/delete_user/?user_id={{ user_obj.id }}" class="btn btn-danger btn-xs">删除</a>
  41.                             </td>
  42.                         </tr>
  43.                     {% endfor %}
  44.                 </table>
  45.             </div>
  46.         </div>
  47.     </div>
  48. </body>
  49. </html>

edit_user.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  7.     <title>数据编辑</title>
  9.     <!--类似于导模块-->
  10.     {% load static %}
  11.     <!-- Bootstrap3 核心 CSS 文件，本地导入 -->
  12.     <link href="{% static "bootstrap-3.3.7-dist/css/bootstrap.min.css" %}" rel="stylesheet">
  13.     <!-- jQuery文件。务必在bootstrap.min.js 之前引入 -->
  14.     <script src="{% static "js/jQuery_3.5.1.js" %}"></script>
  15.     <!-- Bootstrap3 核心 JavaScript 文件 -->
  16.     <script src="{% static "bootstrap-3.3.7-dist/js/bootstrap.min.js" %}"></script>
  17. </head>
  18. <body>
  19.     <div class="container">
  20.         <div class="row">
  21.             <div class="col-md-8 col-md-offset-2">
  22.                 <h1 class="text-center">数据编辑</h1>
  23.                 <form action="" method="post">
  24.                     <p>
  25.                         用户名: <input type="text" name="username" class="form-control" value="{{ edit_obj.username }}">
  26.                     </p>
  27.                     <p>
  28.                         密码: <input type="text" name="password" class="form-control" value="{{ edit_obj.password }}">
  29.                     </p>
  30.                     <input type="submit" class="btn btn-info btn-block" value="编辑">
  31.                 </form>
  32.             </div>
  33.         </div>
  34.     </div>
  35. </body>
  36. </html>

界面效果

Django进阶01 - 图27

Django进阶01 - 图28

补充：

  1. # 真正的删除功能应该需要二次确认 我们这里先不做后面会讲
  2. # 删除数据内部其实并不是真正的删除 我们会给数据添加一个标识字段用来表示当前数据是否被删除了，如果数据被删了仅仅只是讲字段修改一个状态
  3.   username       password        is_delete
  4.   jason           123                0
  5.   egon            123                1