Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb_百度小程序

Django

本套博客基于银角大王武沛齐的django全栈开发视频编写：传送门

如有错误或改进欢迎大家评论、私信交流指正

一、初识Django

1、Djang的安装

在windos命令窗口

win+r键，输入cmd

pip install django

效果:

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221023110511676,第1张

2、Django项目

①创建Django项目

使用Pycham创建

Ⅰ、使用模板

主页面点击左上角File->newProject

Ⅱ、配置选项

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221023171059188,第2张

Ⅲ、成功效果

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221023172109306,第3张

②项目文件

Ⅰ、默认文件介绍

Demo1
├── manage.py         【项目的管理，启动项目、创建app、数据管理】【不需要修改】【***常常用***】
├── templates          【存放html静态页面，后期手动创建】
├── static              【图片、css、js、plugins(插件)等前端样式资源，后期手动创建】
└── Demo1
    ├── __init__.py
    ├── settings.py    【项目配置文件】          【***常常修改***】
    ├── urls.py        【URL和函数的对应关系】【***常常修改***】
    ├── asgi.py        【接收网络请求】【不要动】
    └── wsgi.py        【接收网络请求】【不要动】

③创建App文件

注意：我们开发比较简洁，用不到多app，一般情况下，项目下创建1个app即可。

Ⅰ、终端创建

语法

python manage.py startapp app文件名称

在当前项目目录下执行manage.py文件创建App

Ⅱ、app文件结构

Demo1
├── app01
│   ├── __init__.py
│   ├── admin.py         【固定，不用动】django默认提供了admin后台管理。
│   ├── apps.py          【固定，不用动】app启动类
│   ├── migrations       【固定，不用动】数据库变更记录
│   │   └── __init__.py
│   ├── models.py        【**重要**】，对数据库操作，里面的oim代替了原生的Pymysql来操作数据库。
│   ├── tests.py         【固定，不用动】单元测试
│   └── views.py         【最常用】，列：下面执行url就会调用该文件夹的函数。
├── manage.py
└── Demo1
    ├── __init__.py
    ├── asgi.py
    ├── settings.py      【项目配置文件】
    ├── urls.py          【URL->函数】
    └── wsgi.py

3、快速上手

①项目注册app

Ⅰ、在项目文件夹下Settings.py文件中

app地址格式

'app文件名.apps.类名(apps.py文件中)'

类名

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221023181313400,第4张

填写信息

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221023181016450,第5张

②urls.py编写url和函数信息

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221023182209716,第6张

③views.py编写视图函数

服务器输出层

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221023182612280,第7张

④启动项目

Ⅰ、命令行启动

端口号可以省略默认8000

python manage.py runserver 8080

关闭

ctrl+c

Ⅱ、PyCham启动

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221023185327679,第8张

⑤访问页面

在浏览器访问，前面127.0.0.1.8080 是默认的,而index是要访问的页面和执行函数路径,具体见配置

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221023190334635,第9张

4、访问静态页面

与快速上手步骤无异只是修改了几处位置

①创建html静态页面

在app文件目录下创建一个文件夹templates，里面放置html静态页面
选中templates文件夹，右击new—File—Html,然后取文件名user_list

效果：

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221023190927924,第10张

②编写视图函数

app文件夹下views.py文件

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221023191219600,第11张

④编写url配置文件

Demo1项目文件夹下urls.py文件

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221023171059188,第12张

⑤访问页面

启动

访问效果：

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221023191629221,第13张

⑥总结

访问静态页面返回方法要使用：render()并且要导包

# 调用函数访问静态页面
def user_list(request):
    return render(request,"user_list.html")

普通的直接使用HttpResponse()方法

def index(request):
    return HttpResponse("欢迎使用Django")

⑥拓展templates

页面是默认到App文件目录templates文件夹中找html文件的，但是可以配置让其到项目目录找

添加方法：

os.path.jion()

5、项目文件管理

①静态页面

Ⅰ、存放路径

app文件—templates文件夹

文件夹名称必须为templates不可以修改

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221023193229717,第14张

Ⅱ、拓展（修改存放路径）

页面是默认到App文件目录templates文件夹中找html文件的，但是可以配置让其到项目目录找,可以查看

添加方法

os.path.jion()

②静态文件

图片、css、js、plugins(插件)等前端样式资源

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221023193824517,第16张

6、Django模板语法

①引用文件

Django独特资源路径

通过项目配置文件Settings.py指定文件查找路径，占位符引用资源

作用：

防止以后做项目需要改文件路径，可以直接通过配置文件修改

语法：

效果：

文件所在路径：

配置文件：

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221023195843606,第20张

②返回数据

Ⅰ、render对象

说明

导包

from django.shortcuts import render

使用

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

Ⅱ、HttpResponse对象

说明

导包

from django.shortcuts import HttpResponse

使用

def index(request):
    return HttpResponse("欢迎使用Django") # 结果输出到访问的页面

③占位符开发

使用占位符让python代码可以在html文件中使用

{% python代码 %}

views.py文件

from django.shortcuts import render,HttpResponse
"""
视图函数
"""
def index(request):
    return HttpResponse("欢迎使用Django")
# 调用函数访问静态页面
def user_list(request):
    return render(request,"user_list.html")
def tpl(request):
    name = "胡图图"                     # str
    roles = ["大胖子","小学生","萝卜头"]  # list
    user_info={"name":"胡图图","age":3}
    return render(request,'tpl.html',{"n1":name,"n2":roles,"n3":user_info})  # 转化

html文件




    
    Title



{{ n1 }}}
{{ n2 }}}

{{ n2.0 }}
{{ n2.2 }}


    {% for aaa in  n2 %}
    aaa
    {% endfor %}


{{ n3 }}
{{ n3.name }}
{% for foo in n3.foo %}
   {{ foo }}
{% endfor %}

{% if n1 == "大胖子" %}
    对
{% else %}
    错
{% endif %}

④案例：把python程序的数据输出到页面上

7、请求和响应

①请求

Ⅰ、获取请求方式

获取前端的请求方式

request.method

Ⅱ、获取get请求传递的值

返回值是字典

# 获取在url上传递的值,get请求    url： http://127.0.0.1:8080/UrlDate/?n=1  传递了n=1
request.GET  # 返回值：    返回的是字典

Ⅲ、获取post请求

request.POST

②响应

HttpResponse()

render()

Ⅰ、返回字符串

  # [响应]将字符串返回给请求者
  return HttpResponse("返回内容")

Ⅱ、返回一个页面，并返回模板变量

return render(request, 'url_date.html', {"uuu": "大胖子"})

html文件




    
    Title


{{ uuu }}

Ⅲ、重定向

跳转页面

 # 重定项，访问次函数方法就会跳转页面
 return redirect("https://blog.csdn.net/tyx2985491138?type=blog")

8、用户登录案例

views.py文件

from django.shortcuts import render, HttpResponse, redirect
"""
登录页面
"""
def login_a(request):
    # 用户第一次访问是以get请求，然后通过前端from表单提交是post请求，从第二次就是post请求
    if request.method == "GET":
        return render(request,'login.html')
    else:
        username = request.POST.get("user")
        password = request.POST.get("pwd")
        if username == 'root' and password == '123456':
            # return HttpResponse("登录成功")
              return redirect("https://blog.csdn.net/tyx2985491138?type=blog") # 登录成功重定向跳转页面
        else:
            # return HttpResponse("登录失败")
            return render(request,'login.html',{"loginaaa":"用户名密码错误"}) # 使用模板语言让登录失败可以返回到前端

urls.py文件

from django.urls import path
from app01 import views # 导入app01中views.py文件(书写函数的文件夹)
urlpatterns = [
    
# 用户登录案例
    path('login/', views.login_a),
]

html文件




    
    用户登录


用户登录

    {% csrf_token %}  
    
    
    
    {{ loginaaa }}  
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'db1',  # 数据库名字
        'USER': 'root',     # 用户名
        'PASSWORD': 'root123',  # 密码
        'HOST': '127.0.0.1',  # 安装了MySQL那台机器的host，本地照写
        'PORT': 3306,     
    }
}

③操作数据库

Ⅰ、创建表

models.py文件中:

from django.db import models
# django创建数据库表，django会给翻译为sql语句
class UserInfo(models.Model):
    name = models.CharField(max_length=32)
    password = models.CharField(max_length=64)
    age = models.IntegerField()
    
class Role(models.Model):
     caption = models.CharField(max_length=16)

自动生成的sql语句

"""
   生成的sql语句
"""
    # 写了如上的类dajngo会自动生成如下sql语句,表面是app名+类名
create table app01_userinfo(
    id bigint auto_increment primary key,
    name VARCHAR(32),
    password VARCHAR(64)
    age int
)

执行命令

生成sql

python manage.py makemigrations
python manage.py migrate

效果

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221029162554808,第22张

Ⅱ、删除表

将Role表删掉

在创建表的基础上把models.py文件中，要删除的表的类注释或删除掉即可

from django.db import models
# django创建数据库表，django会给翻译为sql语句
class UserInfo(models.Model):
    name = models.CharField(max_length=32)
    password = models.CharField(max_length=64)
    age = models.IntegerField()
    
# class Role(models.Model):
#     caption = models.CharField(max_length=16)

执行代码

python manage.py makemigrations
python manage.py migrate

Ⅲ、修改表

在创建表的基础上把models.py文件修改即可

class UserInfo(models.Model):
    name = models.CharField(max_length=32)
    password = models.CharField(max_length=64)  # varchar字段
    # 新增列需要设置默认值
    age = models.IntegerField(default=2)   # 设置默认值为2
    data = models.IntegerField(null=True,blank=True)  # int类型，字段名data，可以为空

然后再执行代码

python manage.py makemigrations
python manage.py migrate

2、增删改查

①添加数据

Ⅰ、控制台添加

语法

create()方法

在models.py文件中

类名或表名.objects.create(字段名='数据')

列：

Department.objects.create(title='销售部')
UserInfo.objects.create(name="大胖子",password="110110110",age=3,data=172)

执行代码:

python manage.py makemigrations
python manage.py migrate

Ⅱ、整合前端添加数据

views.py文件

from app01 import models
def orm(request):
    # 在Department文件中执行
    models.Department.objects.create(title="大胖子")
    models.Department.objects.create(title="胡图图")
    return HttpResponse("成功")

urls.py文件

# 测试orm添加数据,访问orm后端执行sql
    path('orm/',views.orm())

②删除数据

Ⅰ、控制台删除

语法delete()

# 删除数据
UserInfo.objects.all(id=3).delete()   # 删除UserInof表中id为3的数据
Department.objects.all().delete()   # 删除全部

③获取数据

语法

类名或表名.objects.all()   # 返回值是列表里面封装了对象，每行的对象。每一行数据都是一个对象

获取全部 all()

# 获得数据
data_list = UserInfo.objects.all()   # 返回值是个列表，封装了每一行的对象
for obj in data_list:   # 使用for循环遍历，每行的对象并取出每行表的数据
    print(obj.id,obj.name,obj.password,obj.age,obj.data)

指定条件获取filter()

first()：获取列表第一个对象

obj = UserInfo.objects.filter(id=1).first()  # 直接返回一个对象
print(obj.id,obj.name,obj.password,obj.age,obj.data)

④修改数据

update()

UserInfo.objects.filter(name="大胖子").update(age=999)

3、综合案例：用户管理

创建app

python manage.py startapp app1

三、Django开发

员工管理系统，基础

Demo2

1、项目初始化

①、删除多余的代码

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221030111336543,第23张

②、创建app

pycharm项目终端中

python manage.py startapp app1

③、注册app

填写的是路径

'app01.apps.App01Config'

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221030110746270,第24张

2、编写数据库

①、设计表结构

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221030120815523,第25张

②、创建表

from django.db import models
"""
部门表
"""
class Department(models.Model):
    # 设置自增的，注释掉是因为pycharm创建项目会默认自动创建id
    # models.BigAutoField(verbose_name='标题',primar=True)       
    title = models.CharField(verbose_name='标题', max_length=32)  # verbose_name='标题'，著名此表头的作用
 
"""
员工表
 """
class UserInfo(models.Model):
    name = models.CharField(verbose_name='姓名', max_length=16)
    password = models.CharField(verbose_name='密码', max_length=64)  # 字符
    age = models.IntegerField(verbose_name="年龄")  # 整型
    #  max_digits:数字长度10,decimal_places:小数有两位,default默认初始值为0
    account = models.DecimalField(verbose_name='账户余额', max_digits=10, decimal_places=2, default=0)
    create_time = models.DateTimeField(verbose_name='入职时间')
    
    """外键部门表"""
    # 无约束
    # depart_id = models.BigIntegerField(verbose_name='部门表ID')   
    # 有约束
    # - to :表与哪张表关联   ,  to_fields :表与哪个字段关联
    # on_delete=models.CASCADE():表示级联删除，部门表的IT部门被删除了，所属IT部门的员工表的员工会连带删除
    # 表头名：depart_id  django会根据to_fields自动生成列名
    depart = models.ForeignKey(to=Department, to_field="id",on_delete=models.CASCADE  
    
    # 置空
    # blank=True:可以为空值,
    # on_delete=models.SET_NULL():部门表的IT部门被删除了，所属IT部门的员工的部门字段会变为null空值，即无所属部门
    # depart = models.ForeignKey(to=Department, to_fields="id", blank=True,on_delete=models.SET_NULL())
    
    """
     在django中约束。在数据库存储的是1和2，约束只能选择哪一部分
    """
    gender_choices= (
        (1, '男'),
        (2, '女')
    )
    gender = models.SmallIntegerField(verbose_name='性别',choices=gender_choices)

③、创建数据库

打开命令终端

win+r  ，输入cmd

登录到mysql

mysql -h localhost -u root -p

创建数据库djangoDemo2,并设置编码UTF-8

 create database djangoDemo2 DEFAULT CHARSET utf8 COLLATE utf8_general_ci;

查看数据库

show databases;

④、修改Settings.py配置文件

将原有的DATABSES全部注释掉，77行左右直接更换如下:注意修改数据库名、用户名、密码

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'djangoDemo2',  # 数据库名字
        'USER': 'root',
        'PASSWORD': '1234',
        'HOST': '127.0.0.1',  # 哪台机器安装了MySQL
        'PORT': 3306, 
    }
}

⑤、django命令生成表

python manage.py makemigrations
python manage.py migrate

⑥、添加数据

控制台添加

选择数据库

USE djangodemo2

添加数据

insert into app_01 app1_department(title) values("销售部"),("IT部");

3、导入静态文件

解压放入app01目录下

static文件：https://wwt.lanzouy.com/iFXts0eu1vre

templates：https://wwt.lanzouy.com/ikXAv0eu1vtg

4、部门管理功能

注意导包,这个项目后面添加的功能不会把导包写出来，只会书写前端没导过的包，从而循循渐进

①、查询

views.py文件

from django.shortcuts import render
from app1 import models
def depart_list(request):
    """部门列表"""
    # 从数据库中获取全部部门信息
    query_set = models.Department.objects.all()
    return render(request, 'depart_list.html', {'queryset': query_set})  # 把数据库信息返回给前端遍历显示

urls.py

from django.urls import path
from app1 import views
urlpatterns = [
    # path('admin/', admin.site.urls),
    path('depart/list/', views.depart_list)，
]

depart_list.html文件

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221031105103594,第26张

②、新增

views.py

from django.shortcuts import redirect
def depart_add(request):
    if request.method == 'GET':
        return render(request, 'depart_add.html')
    # 获取用户提交过来的数据
    title = request.POST.get("title")
    # 保存到数据库
    # create(数据库的列名 = 前端提交的数据)
    models.Department.objects.create(title=title)
    # 重定向，显示所有部门
    return redirect('/depart/list/')

urls.py

  # 新增页面
    path('depart/add/', views.depart_add),

depart_add.html

无修改，使用即可

③、删除

vuews.py

def depart_delete(request):
    # 获取ID
    # http://127.0.0.1:8000/depart/delete/?nid=1
    nid = request.GET.get('nid')
    # 删除
    models.Department.objects.filter(id=nid).delete()
    # 重定向
    return redirect('/depart/list/')    # 重定向路径需要在前面也加个 / 千万要注意

urls.py

# 删除部门
    path('depart/delete/', views.depart_delete),

depart_list.html

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221031161850536,第27张

④、编辑

views.py

def depart_edit(request, nid):
    if request.method == 'GET':
        row_update = models.Department.objects.filter(id=nid).first()
        print(f"被修改的部门id和名称：{row_update.id, row_update.title}")
        return render(request, 'depart_edit.html', {'row_update': row_update.title})
    # 获取用户提交的标题
    title = request.POST.get("title")
    # 根据id找到数据库中的数据并进行更新
    models.Department.objects.filter(id=nid).update(title=title)
    # 重定向返回主页面
    return redirect("/depart/list/")

urls.py

# 编辑部门
    # http://127.0.0.1:8000/depart/4/edit  中间的数字用来分辨是哪个部门
    path('depart//edit/', views.depart_edit),

depart.html

depart_list.html

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221031165509981,第29张

5、django的html继承

继承语法

{% extends 'layout.html' %}   
{% block content %}
    这里写html页面样式，子类自己独有的
{% endblock %}

作用

可以显示父类的所有页面，并在其基础上进行修改，从而实现自己独特的页面，避免了重复的代码

父类.html

这个是父类的，子类继承后也会有

    {% block content %}{% endblock %}

子类.html

{% extends '父类.html' %} 
{% block content %}
    
{% endblock %}

四、员工表的管理功能

①、执行sql让数据库有数据

登录数据库： win+r ，cmd 。mysql -u root -p

选择数据库：USE dangodemo2

执行sql添加数据

insert into app1_userinfo(name,password,age,account,create_time.grdner,depart_id) values("胡图图","110110110",7,100.64,"2022-11-1",2,1);

insert into app1_userinfo(name,password,age,account,create_time.grdner,depart_id) values("大胖子","110110110",7,100.64,"2022-11-1",2,1);

②、查询

views.py

def user_list(request):
    # 获取用户全部值
    user_info_list = models.UserInfo.objects.all()
    # """用python语法,这里是后端的获取数据，加深理解代码 ，把对象传入前端在前端获取值  """
    # for obj in user_info_list:
    #     print(obj.id, obj.name, obj.account, obj.create_time.strftime("%Y-%m-%d"), obj.get_gender_display(),
    #           obj.depart_id, obj.depart.title)
    #     """重点"""
    #     obj.create_time.strftime("%Y-%m-%d") # strftime("%Y-%m-%d")：表显示年月日
    #     obj.get_gender_display()  # 创建员工表时给其定义了，存储数据库1代表是男，2代表是女。这个方法意思是获取规则
    #     obj.depart.title  # 根据id获取，链表的title字段的数据，depart：是models.py文件创建员工表的字段返回值,title则是外键部门表的部门名称字段
    return render(request, 'user_list.html', {'user_info_list': user_info_list})

urls.py

  # 员工管理
    path('user/list/', views.user_list),

user_list.html

obj.get_gender_display()

创建员工表时给其定义了，存储数据库1代表是男，2代表是女。这个方法意思是获取规则，从而更好的显示在数据库
员工表：
因为存储在数据库的数据是1和2

**obj.depart.title **

因为外键去获取另一个表的值，title是部门表的部门名称，通过外键查询
员工表：
效果：

员工表在数据库的样子

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221101113441314,第34张

③、添加（原始方法）

原始方法：麻烦

- 用户提交数据没有校验
- 错误，页面上不能显示错误提示	
- 页面上每一个字段都需要我们写一遍
- 关联的数据，需要我们手动循环一个一个获取

views.py

def user_add(request):
    # 访问页面是get请求，提交数据是post请求
    if request.method == "GET":
        context = {  
            'gender_choices': models.UserInfo.gender_choices,   # 获取所有性别对应的中文
            'depart_list': models.Department.objects.all()      # 获取所有部门
        }
        return render(request, 'user_add.html', context)  # 将字典返回到前端
    # post请求，通过前端表单name值获取每个表单数据
    user = request.POST.get("ruser")
    pwd = request.POST.get("pwd")
    age = request.POST.get("age")
    ac = request.POST.get("ac")
    ctime = request.POST.get("ctime")
    gender = request.POST.get("gd")
    dp = request.POST.get("dp")
    # 将数据添加到数据库中
    models.UserInfo.objects.create(name=user, password=pwd, age=age, account=ac, create_time=ctime, gender=gender,depart_id=dp)
    # 添加成功返回用户列表页面
    return redirect("/user/list")

urls.py

# 添加
    path('user/add/', views.user_add),

user_add.html

{% extends 'layout.html' %}
{% block content %}
    
        
            
                 新建用户 
            
            
                
                    {% csrf_token %}
                    
                        姓名
                        
                    
                    
                        密码
                        
                    
                    
                        年龄
                        
                    
                    
                        余额
                        
                    
                    
                        入职时间
                        
                    
                       
                    
                        性别
                        
                    
                       
                    
                        部门
                        
                    
                    
                
            
        
    
{% endblock %}

效果：

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221101170023952,第35张

④、组件

Form组件(小简便)

ModelForm组件（最简便）

Ⅰ、From组件

简化重复书写表单

views.py

class MyForm(Form):
    user = forms.CharField(widget=forms.Input)
    pwd = form.CharFiled(widget=forms.Input)
    email = form.CharFiled(widget=forms.Input)
    account = form.CharFiled(widget=forms.Input)
    create_time = form.CharFiled(widget=forms.Input)
    depart = form.CharFiled(widget=forms.Input)
    gender = form.CharFiled(widget=forms.Input)
def user_add(request):
    if request.method == "GET":
        form = MyForm()
        return render(request, 'user_add.html',{"form":form})

user_add.html


     
    {{ form.user }}
    {{ form.pwd }}
    {{ form.email }}

使用循环加工


    {% for field in form%}
    	{{ field }}
    {% endfor %}

Ⅱ、ModeForm组件（推荐）

再Form组件的基础上进一步简化

views.py

class MyForm(ModelForm):   # 只有这里有区别
    xxx = form.CharField*("...")    # 自定义字段，也支持自定义生成一个字段
    class Meta:
        model = UserInfo   # UserInfo是创建员工表的类名
        fields = ["name","password","age","account","create_time","depart","gender","xxx"]   # 列表内写的是字段返回值，字段名
def user_add(request):
    if request.method == "GET":
        form = MyForm()
        return render(request, 'user_add.html',{"form":form})

models.py

class UserInfo(models.Model):
    """ 员工表 """
    name = models.CharField(verbose_name="姓名", max_length=16)
    password = models.CharField(verbose_name="密码", max_length=64)
    age = models.IntegerField(verbose_name="年龄")
    account = models.DecimalField(verbose_name="账户余额", max_digits=10, decimal_places=2, default=0)
    create_time = models.DateTimeField(verbose_name="入职时间")
    depart = models.ForeignKey(to="Department", to_field="id", on_delete=models.CASCADE)
    gender_choices = (
        (1, "男"),
        (2, "女"),
    )
    gender = models.SmallIntegerField(verbose_name="性别", choices=gender_choices)

user_add.html


    {% for field in form%}
    	{{ field }}
    {% endfor %}

⑤、ModelForm组件实现添加

views.py

"""
组件实现添加用户
"""
from django import forms
  # 使用组件
class UserModelForm(forms.ModelForm):
    name = forms.CharField(min_length=3, label="用户名")  # 设置name表单接收数据最小值为3
    class Meta:
        model = models.UserInfo
        fields = ["name", "password", "age", "account", "create_time", "gender", "depart"]
        # 定义表单的class属性
        # widgets = {
        #     "name": forms.TextInput(attrs={"class": "form-control"}),
        #     "password": forms.TextInput(attrs={"class": "form-control"}),
        # }
        # 简化上面注释的代码
        # 批量生成，让字段加样式
        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)
            # 循环获取所有插件
            for name, field in self.fields.items():  # 这里的name是字段名
                # if name == "password":   # 让password这个字段不加class
                #     continue
                field.widgets.attrs = {"class": "form-control", "placeholder": field.labels}
def user_model_form_add(request):
    if request.method == "GET":
        form = UserModelForm()
        return render(request, 'user_model_form_add.html', {'form': form})
    # 用户使用post提交数据，数据校验
    form = UserModelForm(data=request.POST)
    if form.is_valid():
        # 逐一校验，数据合法存储入数据库
        # print(form.changed_data)
        form.save()
        return redirect('/user/list/')
    else:
        print(form.errors)  # 将错误信息打印出来
        return render(request, 'user_model_form_add.html', {'form': form})

urls.py

 # 组件实现添加
    path('user/model/form/add', views.user_model_form_add)

setting.py设置中文

```
LANGUAGE_CODE = 'zh-hans' 
```

user_model_form_add.html

{% extends 'layout.html' %}
{% block content %}
    
        
            
                 新建用户 
            
            
                
                    {% csrf_token %}
                    
                    { form.name.label }}: {{ form.name }}-->
                    { form.password.label }}: {{ form.password }}-->
                    
                    
                    {% for field in form %}
                        
                            {{ field.label }}
                            {{ field }}
                            
                            {{ field.errors.0 }} 
                        
                    {% endfor %}
                    
                
            
        
    
{% endblock %}

效果：

models.py

from django.db import models
# Create your models here.
class Department(models.Model):
    """部门表"""
    # models.BigAutoField(verbose_name='标题',primar=True)       # 设置自增的，注释掉是因为pycharm创建项目会默认自动创建
    title = models.CharField(verbose_name='标题', max_length=32)  # verbose_name='标题'，著名此表头的作用
    # 类似于to.string方法
    def __str__(self):
        return self.title
class UserInfo(models.Model):
    """员工表"""
    name = models.CharField(verbose_name='姓名', max_length=16)
    password = models.CharField(verbose_name='密码', max_length=64)  # 字符
    age = models.IntegerField(verbose_name="年龄")  # 整型
    account = models.DecimalField(verbose_name='账户余额', max_digits=10, decimal_places=2, default=0)
    create_time = models.DateTimeField(verbose_name='入职时间')
  
    depart = models.ForeignKey(verbose_name='部门', to=Department, to_field="id", on_delete=models.CASCADE)
   
    gender_choices = (
        (1, '男'),
        (2, '女')
    )
    gender = models.SmallIntegerField(verbose_name='性别', choices=gender_choices)

⑥编辑

使用组件

Ⅰ、思路

点击编辑用户，跳转页面并携带需要编辑的那一行的id get
根据携带过来的id显示一些默认信息（从数据库获取） get

提交：post

错误提示、数据校验

数据库更新数据

Ⅱ、实现

views.py

def user_edit(request, nid):
    row_object = models.UserInfo.objects.filter(id=nid).first()  # 用于告诉ModelForm是要修改哪一行数据，而不是添加
    # 根据id获取要编辑的那一行数据，从而将原来的值显示在页面上
    if request.method == 'GET':
        # row_object = models.UserInfo.objects.filter(id=nid).first()
        form = UserModelForm(instance=row_object)
        name = row_object.name
        return render(request, 'user_edit.html', {'form': form, 'name': name})  # 因为form是字典所以可以直接返回，不用大括号
    # post提交表单请求,并数据校验
    # row_object = models.UserInfo.objects.filter(id=nid).first()  # 用于告诉ModelForm是要修改哪一行数据，而不是添加
    form = UserModelForm(data=request.POST, instance=row_object)
    if form.is_valid():
        form.save()  # 数据合法存储入数据库
        return redirect('/user/list/')
    else:
        return render(request, 'user_edit.html', {'form': form})

urls.py

  # 编辑
    path('user//edit/', views.user_edit),

user_edit.html

需要自己创建

{% extends 'layout.html' %}
{% block content %}
    
   
            
                 编辑{{ name }}用户 
            
            
                
                    {% csrf_token %}
                    
                    { form.name.label }}: {{ form.name }}-->
                    { form.password.label }}: {{ form.password }}-->
                    {% for field in form %}
                        
                            {{ field.label }}
                            {{ field }}
                            
                            {{ field.errors.0 }}
                        
                    {% endfor %}
                    
                
            
        
    
{% endblock %}

user_list.html

修改一些内容

效果

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221103001909304,第39张

⑦删除

views.py

"""
删除用户
"""
def user_delete(request):
    # 获取ID
    # http://127.0.0.1:8000/depart/delete/?nid=1
    nid = request.GET.get('nid')  # 获取删除按钮通过表单传达过来的nid值
    print(nid)
    models.UserInfo.objects.filter(id=nid).delete()
    return redirect('/user/list/')

urls.py

# 删除
    path('user/delete/', views.user_delete),

user_list.html

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221103003504460,第40张

五、靓号管理

①创建表

class PrettyNum(models.Model):
    mobile = models.CharField(verbose_name="手机号", max_length=11)
    # 想要允许为空 null=True ,blank = True
    price = models.IntegerField(verbose_name="价格")
    # 级别
    level_choice = (
        (1, '1级'),
        (2, '2级'),
        (3, '3级'),
        (4, '4级'),
    )
    level = models.SmallIntegerField(verbose_name="级别", choices=level_choice, default=1)  # 小整型
    status_choices = (
        (1, '已占用'),
        (2, '未占用'),
    )
    status = models.SmallIntegerField(verbose_name="级别", choices=status_choices, default=2)

②靓号列表

将ID、号码、价格、级别（中文）、状态（中文）、操作（编辑和删除）展现出来

views.py

def admin_list(request):
    # order_by（）设置排序,select * from 表名 order by level desc
    queryset = models.PrettyNum.objects.all().order_by("-level")  # 加-则表示desc，不加-则表示level
    return render(requesret, 'admin_list.html', {'queryset': queryset})

urls.py

 # 靓号列表主页面
    path('admin/list/', views.admin_list),

admin_list.html

{% extends 'layout.html ' %}
{% block content %}
    
        
            
                
                添加靓号
            
        
        
            
            
                
                靓号列表
            
            
            
                {% for obj in queryset %}
                    
                {% endfor %}
                
                
                
                    ID
                    号码
                    价格
                    级别
                    状态
                    操作
                
                
                
                        {{ obj.id }}
                        {{ obj.mobile }}
                        {{ obj.price }}
                        {{ obj.get_level_display }}
                        {{ obj.get_status_display }}
                        
                            编辑
                            删除
                        
                    
            
        
    
{% endblock %}

ID	号码	价格	级别	状态	操作
{{ obj.id }}	{{ obj.mobile }}	{{ obj.price }}	{{ obj.get_level_display }}	{{ obj.get_status_display }}	编辑删除

④添加

通过正则表达式校验数据

views.py

from django.core.validators import RegexValidator
from django.core.exceptions import ValidationError
class UserModForm2(forms.ModelForm):
    # 验证：方法1
    # mobile = forms.CharField(
    #     label="手机号",
    #     validators=[RegexValidator(r'^\d{11}$', '手机号必须为11位数')]  # 使用正则表达式对其加强校验
    # )
    class Meta:
        model = models.PrettyNum  # 选择表
        fields = ["mobile", "price", "level", "status"]  # 这个是自己选哪些字段
        # fields = "__all__"   # 这个是所有字段
        # exclude = ['level']  # 这个是排除哪个字段
    """加载样式"""
    # def __init__(self, *args, **kwargs):
    #     super().__init__(*args, **kwargs)
    #     # 循环获取所有插件
    #     for name, field in self.fields.items():  # 这里的name是字段名
    #         # if name == "password":   # 让password这个字段不加class
    #         #     continue
    #         # 设置生成的表单class值为"form-control"
    #         field.widgets.attrs = {"class": "form-control", "placeholder": field.labels}
    # 验证：方法2
    def clean_mobile(self):
        txt_mobile = self.cleaned_data["mobile"]  # 获取"mobile"字段用户输入的值
        if len(txt_mobile) != 11:
            # 验证不通过
            raise ValidationError("格式错误")
        # 验证通过,用户输入的值返回
        return txt_mobile
def admin_add(request):
    if request.method == 'GET':
        form = UserModForm2()
        return render(request, 'admin_add.html', {'form': form})
    # post请求
    form = UserModForm2(data=request.POST)
    if form.is_valid():  # 一个一个校验数据
        form.save()  # 添加进入数据库
        return redirect('/admin/list/')
    else:
        print(form.errors)  # 打印错误信息
        return render(request, 'admin_add.html', {'form': form})

urls.py

    # 添加
    path('admin/add/', views.admin_add),

admin_add.html

{% extends 'layout.html' %}
 {% block content %}
       
        
            
                 添加靓号 
            
            
                
                    {% csrf_token %}
                    {% for field in form %}
                        
                            {{ field.label }}
                            {{ field }}
                            
                            {{ field.errors.0 }}
                        
                    {% endfor %}
                    
                
            
        
    
 {% endblock %}

⑤编辑

电话号码不可编辑，但还是要显示到页面上
点击编辑后会携带靓号的id到后端从而修改

views.py

def admin_edit(request, nid):
    row_object = models.PrettyNum.objects.filter(id=nid).first()
    if request.method == "GET":
        form = UserModForm2(instance=row_object)
        return render(request, 'admin_edit.html', {'form': form})
    form = UserModForm2(data=request.POST, instance=row_object)
    if form.is_valid():
        form.save()
        return redirect('/admin/list')
    else:
        return render(request, 'admin_edit.html', {'form': form})

urls.py

  # 编辑
    path('admin//edit/', views.admin_edit),

admin_edit.html

{% extends 'layout.html' %}
{% block content %}
    
   
            
                 编辑靓号 
            
            
                
                    {% csrf_token %}
                    {% for field in form %}
                        
                            {{ field.label }}
                            {{ field }}
                            
                            {{ field.errors.0 }}
                        
                    {% endfor %}
                    
                
            
        
    
{% endblock %}

⑥删除

views.py

def admin_delete(request):
    nid = request.GET.get('nid')   # 前端的？nid = {{obj.id}} ,?是占位符代表给nid赋值
    models.PrettyNum.objects.filter(id=nid).delete()
    return redirect('/admin/list')

urls.py

# 删除
    path('admin/delete/', views.admin_delete)

admin_list.html

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221104174406074,第41张

⑦搜索查询

手机号搜索

Ⅰ、views.py

修改原主页函数文件

def admin_list(request):
    """查询所有"""
    # order_by（）设置排序,select * from 表名 order by level desc
    # queryset = models.PrettyNum.objects.all().order_by("-price")  # 加-则表示正序，不加-则表示倒叙，按价格从高到低
    # return render(request, 'admin_list.html', {'queryset': queryset})
    """搜索查询"""
    data_dict = {}
    search_data = request.GET.get('q', "")
    if search_data:
        data_dict["mobile__contains"] = search_data
    queryset = models.PrettyNum.objects.filter(**data_dict).order_by("-price")  # 按条件查询
    return render(request, 'admin_list.html', {'queryset': queryset, 'search_data': search_data})

Ⅱ、urls.py

不改变

 # 靓号列表主页面
    path('admin/list/', views.admin_list),

Ⅲ、admin_list.html

将原主页修改
搜索框样式是bootstrap：官网https://v3.bootcss.com/ 样式包（bootstrap-3.4.1)：https://wwt.lanzouy.com/iYMpj0f7fgze

导入样式包（bootstrap-3.4.1)

代码

⑧分页查询

给数据库添加300条数据

写在views.py的admin_list函数中，访问即可给数据库添加300条数据

# 添加300条数据
    for i in range(300):
        models.PrettyNum.objects.create(mobile="16656678912", price=10, level=1, status=1)

Ⅰ、sql语法:

 queryset = models.PrettyNum.objects.filter(**data_dict).order_by("-price")[初始分页索引:结尾id]

Ⅱ、views.py

def admin_list(request):
    """查询所有"""
    # order_by（）设置排序,select * from 表名 order by level desc
    # queryset = models.PrettyNum.objects.all().order_by("-price")  # 加-则表示正序，不加-则表示倒叙，按价格从高到低
    # return render(request, 'admin_list.html', {'queryset': queryset})
     """搜索查询"""
    data_dict = {}
    search_data = request.GET.get('q', "")
    if search_data:
        data_dict["mobile__contains"] = search_data
        
    """分页"""
    # 获取get请求传递的值，page默认值为1,当前页码
    x = int(request.GET.get('p', 1))   # 搜索页码的值
    if x > 1:
        page = x
    page = int(request.GET.get('page', 1))   # 页码输入的当前页码
    # 当前页码,根据用户想要访问的页面，计算出起止位置
    page_size = 10  # 显示10条数据
    start = (page - 1) * page_size
    end = page * page_size
    # 按条件查询
    queryset = models.PrettyNum.objects.filter(**data_dict).order_by("-price")[start:end]
    # 数据总条数
    total_count = models.PrettyNum.objects.filter(**data_dict).order_by("-price").count()
    
    """页码"""
    # 总页码 = 数据总条数/每页显示数据条数
    total_page_count, div = divmod(total_count, page_size)
    # if div:
    #     total_page_count += 1
    # 计算，显示出当前页的前五页和后五页
    plus = 5  # 显示前后页码条数
    if total_page_count <= 2 * plus + 1:  # 小于11页
        # 数据库数据较少没有超过十一页，把所有页码显示
        start_page = 1
        end_page = total_page_count
    else:
        # 数据库数据大于11页数据
        # 当前页小于5（小极值）
        if page <= plus:  # page是前端用户传入要访问的页数
            start_page = 1
            end_page = 2 * plus + 1
        else:
            # 当前页+显示条数>总页码
            if (page + plus) > total_page_count:
                start_page = total_page_count - 2 * plus
                end_page = total_page_count
            else:
                start_page = page - plus  # 当前页减5
                end_page = page + plus  # 后五页
    # 自动生成页码(前端样式)
    page_str_list = []
    # 上一页
    if page > 1:
        prev = '上一页'.format(page - 1)  # 当前页减一
    else:
        prev = '上一页'.format(1)
    page_str_list.append(prev)
    # for i in range(1, total_page_count + 1):  # 初始页面和总页码
    for i in range(start_page, end_page + 1):  # +1 因为数据库搜索出来数据总数会少1
        if i == page:  # 判断是当前页的话给其添加样式
            elc = '{}'.format(i, i)
        else:
            elc = '{}'.format(i, i)
        page_str_list.append(elc)  # 将添加进列表中
    # 下一页
    if page < total_page_count:
        prev = '下一页'.format(page + 1)  # 当前页加1
    else:
        prev = '下一页'.format(total_page_count)  # 总页码
    page_str_list.append(prev)
    # 尾页
    one = '尾页'.format(total_page_count)
    page_str_list.append(one)
    # 使用mark_safe包裹就可以将字符串转化成html，在导包的前提下from django.utils.safestring import mark_safe
    page_string = mark_safe("".join(page_str_list))
    return render(request, 'admin_list.html',
                  {'queryset': queryset, 'search_data': search_data, "page_string": page_string})

urls.py

不做更改

Ⅲ、admin_list.html


        
            {#        1#}
            {#        2#}
            {#        3#}
            {#        4#}
            {#        5#}
            {{ page_string }}

Ⅳ、效果：

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221106230715505,第43张

⑨、使用封装简化分页代码（封装分页）

Ⅰ、views.py

def admin_list(request):
    """查询所有"""
    # order_by（）设置排序,select * from 表名 order by level desc
    # queryset = models.PrettyNum.objects.all().order_by("-price")  # 加-则表示正序，不加-则表示倒叙，按价格从高到低
    # return render(request, 'admin_list.html', {'queryset': queryset})
    """搜索查询"""
    data_dict = {}
    search_data = request.GET.get('q', "")
    if search_data:
        data_dict["mobile__contains"] = search_data
    """分页"""
    from app1.utils.pagination import Pagination
    # 按条件查询
    # queryset = models.PrettyNum.objects.filter(**data_dict).order_by("-price")[page_object.start: page_object.end]
    queryset = models.PrettyNum.objects.filter(**data_dict).order_by("-price")
    page_object = Pagination(request, queryset)  # 获取自定义组件类
    page_queryset = page_object.page_queryset  # 获取分页完的数据
    page_string = page_object.html()  # 生成的页码
    context = {
        "queryset": page_queryset,
        "search_date": search_data,  # 分完页的数据
        "page_string": page_string  # 生成的页码
    }
    return render(request, 'admin_list.html', context)  # 使用组件后

Ⅱ、pagination.py

在app1中创建utils文件夹里面创建paginaion.py

将页码生成、数据获取、前端页码生成封装到pagination.py文件中Pagination类中

"""
自定义分页组件
"""
from django.utils.safestring import mark_safe
from django import forms
class Pagination(object):
    def __init__(self, request, queryset, page_size=10, page_param="page", plus=5):
        """
        :param request: 请求的对象
        :param queryset:查询的数据，符合条件的数据对这个进行分页处理
        :param page_size:每页显示多条数据
        :param page_param:在URL中传递获取分页的参数，列如:/etty/list/https://blog.csdn.net/tyx2985491138/article/details/131528972?page=12
        :param plus:显示当前页的，前、后几页（页码）
        """
        import copy
        query_dict = copy.deepcopy(request.GET)
        query_dict._mutable = True
        self.query_dict = query_dict
        self.page_param = page_param
        page = request.GET.get(page_param, "1")  # 把request获取前端get请求的方法，封装到page中，页码
        if page.isdecimal():  # 处理页码，判断页码是否是正常传入数字，而不是字符串
            page = int(page)
        else:
            page = 1  # 前端传入页码不规范，则默认为1
        self.page = page
        self.page_size = page_size
        # 计算分页页码，sql值
        self.start = (page - 1) * page_size
        self.end = page * page_size
        self.page_queryset = queryset[self.start: self.end]  # 分完页的数据
        # total_count = models.PrettyNum.objects.filter(**data_dict).order_by("-price").count()
        total_count = queryset.count()  # 数据总条数
        total_page_count, div = divmod(total_count, page_size)  # 总页码 = 数据总条数/每页显示数据条数
        if div:
            total_page_count += 1
        self.total_page_count = total_page_count
        self.plus = plus  # 显示前后页码条数
    def html(self):
        """
          页码、页码搜索
          """
        # 计算出，显示当前页的前5页、后5页
        if self.total_page_count <= 2 * self.plus + 1:
            # 数据库中的数据比较少，都没有达到11页。
            start_page = 1
            end_page = self.total_page_count
        else:
            # 数据库中的数据比较多 > 11页。
            # 当前页<5时（小极值）
            if self.page <= self.plus:
                start_page = 1
                end_page = 2 * self.plus + 1
            else:
                # 当前页 > 5
                # 当前页+5 > 总页面
                if (self.page + self.plus) > self.total_page_count:
                    start_page = self.total_page_count - 2 * self.plus
                    end_page = self.total_page_count
                else:
                    start_page = self.page - self.plus
                    end_page = self.page + self.plus
        # 页码
        page_str_list = []
        self.query_dict.setlist(self.page_param, [1])
        page_str_list.append('首页'.format(self.query_dict.urlencode()))
        # 上一页
        if self.page > 1:
            self.query_dict.setlist(self.page_param, [self.page - 1])
            prev = '上一页'.format(self.query_dict.urlencode())
        else:
            self.query_dict.setlist(self.page_param, [1])
            prev = '上一页'.format(self.query_dict.urlencode())
        page_str_list.append(prev)
        # 页面
        for i in range(start_page, end_page + 1):
            self.query_dict.setlist(self.page_param, [i])
            if i == self.page:
                ele = '{}'.format(self.query_dict.urlencode(), i)
            else:
                ele = '{}'.format(self.query_dict.urlencode(), i)
            page_str_list.append(ele)
        # 下一页
        if self.page < self.total_page_count:
            self.query_dict.setlist(self.page_param, [self.page + 1])
            prev = '下一页'.format(self.query_dict.urlencode())
        else:
            self.query_dict.setlist(self.page_param, [self.total_page_count])
            prev = '下一页'.format(self.query_dict.urlencode())
        page_str_list.append(prev)
        # 尾页
        self.query_dict.setlist(self.page_param, [self.total_page_count])
        page_str_list.append('尾页'.format(self.query_dict.urlencode()))
        search_string = """
                   
                       
                           
                           
                       
                   
                   """
        page_str_list.append(search_string)
        page_string = mark_safe("".join(page_str_list))
        return page_string

Ⅲ、效果

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221107161937082,第44张

六、拓展功能(1)

1、时间插件

插件链接：https://wwt.lanzouy.com/imuOd0fe3opc

用于美化、简化入职时间填写，可以直接通过点击xuan’ze

2、分模块开发

将views.py中用户管理、部门管理、靓号管理分为三个py文件,代码不用改，只需改urls.py中函数路径
views文件夹

urls.py

重点在导包，和函数路径

from django.contrib import admin
from django.urls import path
from app1 import views
from app1.views import admin, list, user   # 导入views文件
urlpatterns = [
    # path('admin/', admin.site.urls),
    # 部门管理
    # 主页面、列表页面
    path('depart/list/',list.depart_list),
    # 新增部门
    path('depart/add/', list.depart_add),
    # 删除部门
    path('depart/delete/', list.depart_delete),
    # 编辑部门
    # http://127.0.0.1:8000/depart/4/edit  中间的数字用来分辨是哪个部门
    path('depart//edit/', list.depart_edit),
    # 员工管理
    path('user/list/', user.user_list),
    # 添加
    path('user/add/', user.user_add),
    # 组件实现添加
    path('user/model/form/add', user.user_model_form_add),
    # 编辑
    path('user//edit/', user.user_edit),
    # 删除
    path('user/delete/', user.user_delete),
    # 靓号管理
    # 靓号列表主页面
    path('admin/list/', admin.admin_list),
    # 添加
    path('admin/add/', admin.admin_add),
    # 编辑
    path('admin//edit/', admin.admin_edit),
    # 删除
    path('admin/delete/', admin.admin_delete)
]

七、管理员

1、创建数据库

models.py

class VIP(models.Model):
    username = models.CharField(verbose_name="用户名", max_length=32)
    password = models.CharField(verbose_name="密码", max_length=64)

执行代码

python manage.py makemigrations
python manage.py migrate

2、管理员列表

VIP.py

在views文件夹中创建VIP.py文件

from django.shortcuts import render, redirect
from app1 import models
# 分页自定义模块
from app1.utils.pagination import Pagination
"""
管理员列表
"""
def VIP_list(request):
    # 搜索功能
    # 构造搜索条件
    data_dict = {}
    search_data = request.GET.get('q', "")
    if search_data:
        data_dict["username__contains"] = search_data
    # 根据条件去数据库获取
    queryset = models.VIP.objects.filter(**data_dict)
    # 分页
    page_object = Pagination(request, queryset)
    queryset = {
        'queryset': queryset,
        'page_string': page_object.html(),
        'search_data': search_data,
    }
    return render(request, 'VIP_list.html', queryset)

urls.py

# 主页面
path('VIP/list', VIP.VIP_list),

VIP.html

{% extends 'layout.html ' %}
{% block content %}
    
        
            
                
                添加管理员
            
            
                
                    
                           
                        
                        
                            
                    
                    
                
            
        
        
            
            
                
                管理员账户列表
            

            
            
                {% for obj in queryset %}
                    
                {% endfor %}
                
                
                
                    ID
                    号码
                    密码
                    重置密码
                    操作
                
                
                
                        {{ obj.id }}
                        {{ obj.username }}
                        ********
                        
                            重置密码
                        
                        
                            编辑
                            删除
                        
                    
            
        
        
        
            {{ page_string }}   
        
    
{% endblock %}

ID	号码	密码	重置密码	操作
{{ obj.id }}	{{ obj.username }}	********	重置密码	编辑删除

3、添加

重点：密码校验

VIP.py

views文件夹下

from django import forms
from django.core.exceptions import ValidationError
from app1.utils.bootstrap import BootStrapModeForm  # 创建input框
from app1.utils.encrypt import md5  # 加密
# 使用组件创建input框
class VIPModelForm(BootStrapModeForm):  # 或者继承forms.Modelform
    # 额外生成一个确认密码表单
    confirm_password = forms.CharField(
        label="确认密码",
        widget=forms.PasswordInput(render_value=True)  # 输入密码时候不会显示密码,render_value=True表示密码错了密码不需要重新输入
    )
    class Meta:
        model = models.VIP
        fields = ["username", "password", "confirm_password"]
        # 给原有字段，生成的表单添加额外修饰
        widgets = {
            "password": forms.PasswordInput(render_value=True)
        }
    # 加密
    def clean_password(self):
        pwd = self.cleaned_data.get("password")
        return md5(pwd)  # 调用加密函数给input框的数据加密，并将加完密的函数返回，则下面方法获取该表单都是加密了的
    # 钩子函数，获取指定字段用户输入的值
    def clean_confirm_password(self):
        #   form.cleaned_data  获取校验成功后所有数据,具体看上面定义的clean_confirm_password钩子函数
        password = self.cleaned_data.get("password")  # 因为上面给表单加密了，所以这里获取的值是加密的值
        confirm = md5(self.cleaned_data.get("confirm_password"))  # 获取确认用户表单，用户输入的值，并使其加密从而可以使密文和密文进行比较
        if confirm != password:
            raise ValidationError("密码不一致")  # 抛出异常到前端，需要导包
        return confirm  # 这里返回的值就是存储入数据库的值
def VIP_add(request):
    title = "添加管理员"
    if request.method == "GET":
        form = VIPModelForm()
        return render(request, 'change.html', {"title": title, "form": form})
    # post请求校验数据，并跳转主页面
    form = VIPModelForm(data=request.POST)
    if form.is_valid():
        # 上面的钩子函数也是校验数据
        form.save()
        return redirect('/VIP/list')
    # 有错误信息，则还是在添加页面，并可以看到错误信息
    return render(request, 'change.html', {"title": title, "form": form})

urls.py

    # 添加管理员
    path('VIP/add', VIP.VIP_add),

change.html

因为添加的页面文件都差不多一样，所以可以使用一个文件，只是在需要不同的地方给其自定义


{% extends 'layout.html' %}
 {% block content %}
       
        
            
                 {{ title }}
   
            
            
                
                    {% csrf_token %}
                    {% for field in form %}
                        
                            {{ field.label }}
                            {{ field }}
                            
                            {{ field.errors.0 }}
                        
                    {% endfor %}
                    
                
            
        
    
 {% endblock %}

encrypt.py

自定义的密码校验工具类，放在app01/utils/下
密码和确认密码比较也是使用加密后的密码进行比较

原理是将密码嵌入到django配置文件随机生成的字符串中，具体见第8行代码

import hashlib
from django.conf import settings
"""
给字符串加密
"""
def md5(data_string):
    obj = hashlib.md5(settings.SECRET_KEY.encode('utf-8'))   # SECRET_KEY是django的配置文件Setting随机生成的一个字符串
    obj.update(data_string.encode('utf-8'))
    return obj.hexdigest()

4、编辑

VIP.py

views文件夹子文件

class VIPEditModelForm(BootStrapModeForm):
    class Meta:
        model = models.VIP
        fields = ["username"]  # 只允许修改用户名
def VIP_edit(request, nid):
    title = "编辑管理员"
    row_object = models.VIP.objects.filter(id=nid).first()
    if not row_object:  # 判断是否有这个用户，没有就证明id为错误的
        return redirect('/VIP/list')
    if request.method == "GET":
        form = VIPEditModelForm(instance=row_object)  # 将原来的值显示在页面上
        return render(request, 'change.html', {"title": title, "form": form})
    # 提交数据
    form = VIPEditModelForm(data=request.POST, instance=row_object)
    if form.is_valid():
        form.save()
        return redirect('/VIP/list')
    return render(request, 'change.html', {"title": title, "form": form})

urls.py

  # 编辑
    path('VIP//edit/', VIP.VIP_edit),

change.html

和如上添加管理员使用同一个html，只是有一些区别在views.py文件(VIP.py)中

5、删除

VIP.py

def VIP_delete(request):
    nid = request.GET.get('nid')
    models.VIP.objects.filter(id=nid).delete()
    return redirect('/VIP/list')

urls.py

   # 删除
    path('VIP/delete/', VIP.VIP_delete),

注意把管理员的主页面按钮路径改一下

6、重置密码

views.py

# 使用组件创建input框
class VIPresetModelForm(BootStrapModeForm):  # 或者继承forms.Modelform
    # 额外生成一个确认密码表单
    confirm_password = forms.CharField(
        label="确认密码",
        widget=forms.PasswordInput(render_value=True)  # 输入密码时候不会显示密码,render_value=True表示密码错了密码不需要重新输入
    )
    class Meta:
        model = models.VIP
        fields = ["password", "confirm_password"]
        # 给原有字段，生成的表单添加额外修饰
        widgets = {
            "password": forms.PasswordInput(render_value=True)
        }
    # 加密
    def clean_password(self):
        pwd = self.cleaned_data.get("password")
        md5_pwd = md5(pwd)  # 调用加密函数给input框的数据加密，并将加完密的函数返回，则下面方法获取该表单都是加密了的
        # 去数据库校验之前密码和新输入的密码是否一致
        exists = models.VIP.objects.filter(id=self.instance.pk, password=md5_pwd)  # 返回的是布尔值
        if exists:
            raise ValidationError("密码使用过，请尝试重新输入密码")
        return md5_pwd
    # 钩子函数，获取指定字段用户输入的值
    def clean_confirm_password(self):
        #   form.cleaned_data  获取校验成功后所有数据,具体看上面定义的clean_confirm_password钩子函数
        password = self.cleaned_data.get("password")  # 因为上面给表单加密了，所以这里获取的值是加密的值
        confirm = md5(self.cleaned_data.get("confirm_password"))  # 获取确认用户表单，用户输入的值，并使其加密从而可以使密文和密文进行比较
        if confirm != password:
            raise ValidationError("密码不一致")  # 抛出异常到前端，需要导包
        return confirm  # 这里返回的值就是存储入数据库的值
def VIP_reset(request, nid):
    row_object = models.VIP.objects.filter(id=nid).first()
    if not row_object:
        return redirect('/VIP/list')
    title = "重置用户：{} 密码".format(row_object.username)
    if request.method == 'GET':
        form = VIPresetModelForm()
        return render(request, 'change.html', {"title": title, "form": form})
    # 提交数据
    form = VIPresetModelForm(data=request.POST, instance=row_object)
    if form.is_valid():
        form.save()
        return redirect('/VIP/list')
    return render(request, 'change.html', {"title": title, "form": form})

urls.py

 # 重置密码
    path('VIP//reset/', VIP.VIP_reset),

BootStrap.py

自定义的工具包，因为重置密码使用的是form而不是ModelForm所以使用继承改装一下

from django import forms
"""
添加样式,实际是给每个表单创建class属性
"""
class BootStrap:
    def __int__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        # 循环Modelform中所有字段，给每个字段的插件设置
        for name, field in self.field.items():
            # 字段中有属性，保留原来的属性，没有属性才增加
            if field.widget.attrs:
                field.widget.attrs["class"] = "form-control"
                field.widget.attrs["placeholder"] = field.label
            else:
                field.widget.attrs = {
                    "class": "form-control",
                    "placeholder": field.label
                }
class BootStrapModeForm(BootStrap, forms.ModelForm):
    pass
class BootStrapForm(BootStrap, forms.Form):
    pass

change.html

八、拓展功能(2)

1、管理员登录

views.py

from django.shortcuts import render, redirect, HttpResponse
from app1.utils.encrypt import md5
from app1 import models
"""
登录
"""
# 使用form做
from django import forms
from app1.utils.bootstrap import BootStrapForm
class LoginForm(BootStrapForm):  # Form需要自定义字段，
    username = forms.CharField(
        label="用户名",
        widget=forms.PasswordInput(attrs={"class": "form-control"})  # 定义标签
    )
    password = forms.CharField(
        label="密码",
        widget=forms.PasswordInput(attrs={"class": "form-control"}, render_value=True)  # 密码标签
    )
    # 钩子函数，给密码加密，从而可以使数据与后端密码比较
    def clean_password(self):
        pwd = self.cleaned_data.get("password")
        return md5(pwd)
# # ModelForm则是从数据库中拿字段,去数据库拿安全性差些
# class LoginModelForm(forms.ModelForm):
#     class Meta:
#         model = models.VIP
#         fields = ['username', 'password']
def login(request):
    if request.method == "GET":
        form = LoginForm()
        return render(request, 'login.html', {'form': form})
    form = LoginForm(data=request.POST)
    if form.is_valid():
        # form.cleaned_data获取前端用户输入的值（用户名和密码）
        # print(form.cleaned_data)  # 验证成功，获取到的用户名和密码,因为form与modelForm不同，form不与数据库关联不可以直接写入数据库
        # 去数据库校验用户名和密码是否正确
        # 因为上面有个钩子函数，给form.cleaned_data方法加密了，所以这个获取的也是加密的密码
        first = models.VIP.objects.filter(**form.cleaned_data).first()
        # first = models.VIP.objects.filter(username="xxx", password="xxx").first()  ，如上代替具体见搜索手机号详解,只有字典可以这么用
        if not first:
            form.add_error("password", "用户密码错误")  # 给password字段主动添加错误，password从上面18行创建字段表单获取的
            # 存储session到数据库django_session表中自动创建的，也就是用户cookie的凭证，使用cookie的时候得用session来辨别用户
        # request.session["info"] = {'id': filter.id, 'username': first.username}  # 获取用户id和username存储到session中，来当用户凭证
        request.session["info"] = first.username   # 这里只存储个username
        return redirect("/VIP/list/")
    return render(request, 'login.html', {'form': form})

urls.py

 # 登录
    path('login/', login.login),

{% load static %}



    
    Title
    
    



    用户登录
    
        {% csrf_token %}
        
            用户名
            {{ form.username }}
            {{ form.username.errors.0 }}
        
        
            密码
            {{ form.password }}
            {{ form.password.errors.0 }}

cookie和session

request.session["info"] = {'id': filter.id, 'username': first.username}  # 获取用户id和username存储到session中，来当用户凭证
        request.session["info"] = first.username   # 这里只存储个username

2、校验用户登录

①校验登录

原理是通过session来获取cookie,如果没有cookie就没有登录过

 # 校验是否登录，没登陆跳转登录页面
    info = request.session.get("info")   # 获取session的info字典的用户cookie凭证
    if not info:
        return redirect('/login/')

②中间件校验

因为中间键的使用所以，不需要每个views.py中都使用如上代码校验登录。只需要定义一个中间件即可，函数文件中代码不需要改变

创建中间件

在app1下创建个文件夹middleware，再创建个auth.py。里面代码如下

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse,redirect
# 中间件校验用户是否登录
class AuthMiddleware(MiddlewareMixin):
    """中间件1"""
    def process_request(self, request):
        # 排除那些不需要登录校验的页面
        if request.path_info == "/login/":
            return
        # 读取当前访问的用户session信息,如若读到证明登录过，则继续执行
        info_dict = request.session.get("info")
        if info_dict:
            return
        # 没有登录信息
        return redirect('/login/')

注册中间件

setting.py文件中,每个类是一个中间件

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221112112435796,第46张

3、注销

原理

删除cookie即可，因为没有cookie需要重新登录

def logout(request):
    request.session.clear()  # 将当前用户的session删除掉，等于将用户cookie删除
    return redirect('/login/')

urls.py

 # 注销
    path('logout/', login.logout),

layout.html

将html的注销标签的执行函数地址改一下

注销

4、显示当前用户名

随着用户改变用户名也会跟着自动改变

获取当前用户的账号和密码

# 通过session来获取当前用户的账号和密码
    info = request.session.get("info")   # 获取session的info字典的用户cookie凭证
    # 取值，存储在session中用户输入的账号和密码
    info["id"]   
    info["username"]

应用在前端

{{ request.session.info.username }}

效果：

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221112115837199,第47张

获取的是login.py文件夹存储入session的值：

Django银角大王武沛齐配套视频笔记，python全栈开发、pythonWeb,image-20221112115758287,第48张

5、图片验证码

①pillow插件

自动生成验证码图片插件

Ⅰ、安装插件

pip install pillow

或者到pycham设置中项目-python解释器中安装

Ⅱ、使用

参考文献：https://www.cnblogs.com/wupeiqi/articles/5812291.html

Ⅲ、字体文件

生成验证码的字体：

Ⅳ、验证码的生成与校验

code.py

自定义的工具包文件,注意修改第4行的字体路径，这个字体是和app1在同一个目录下

import random
from PIL import Image, ImageDraw, ImageFont, ImageFilter
def check_code(width=120, height=30, char_length=5, font_file='Monaco.ttf', font_size=28):
    code = []
    img = Image.new(mode='RGB', size=(width, height), color=(255, 255, 255))
    draw = ImageDraw.Draw(img, mode='RGB')
    def rndChar():
        """
        生成随机字母
        :return:
        """
        # return str(random.randint(0, 9))  # 生成数字
        return chr(random.randint(65, 90))  # 生成字母
    def rndColor():
        """
        生成随机颜色
        :return:
        """
        return random.randint(0, 255), random.randint(10, 255), random.randint(64, 255)
    # 写文字
    font = ImageFont.truetype(font_file, font_size)
    for i in range(char_length):
        char = rndChar()
        code.append(char)
        h = random.randint(0, 4)
        draw.text([i * width / char_length, h], char, font=font, fill=rndColor())
    # 写干扰点
    for i in range(40):
        draw.point([random.randint(0, width), random.randint(0, height)], fill=rndColor())
    # 写干扰圆圈
    for i in range(40):
        draw.point([random.randint(0, width), random.randint(0, height)], fill=rndColor())
        x = random.randint(0, width)
        y = random.randint(0, height)
        draw.arc((x, y, x + 4, y + 4), 0, 90, fill=rndColor())
    # 画干扰线
    for i in range(5):
        x1 = random.randint(0, width)
        y1 = random.randint(0, height)
        x2 = random.randint(0, width)
        y2 = random.randint(0, height)
        draw.line((x1, y1, x2, y2), fill=rndColor())
    img = img.filter(ImageFilter.EDGE_ENHANCE_MORE)
    return img, ''.join(code)

    
            图片验证码
            
                
{#                    #}
{#                    #}
                    {{ form.code }}
                    {{ form.code.errors.0 }}

auth.py中间件

核心代码53-58

from django.shortcuts import render, redirect, HttpResponse
from app1.utils.encrypt import md5
from app1 import models
from app1.utils.code import check_code
from io import BytesIO
# 使用form做
from django import forms
from app1.utils.bootstrap import BootStrapForm
class LoginForm(BootStrapForm):  # Form需要自定义字段，
    username = forms.CharField(
        label="用户名",
        widget=forms.TextInput(attrs={"class": "form-control"})  # 定义标签
    )
    password = forms.CharField(
        label="密码",
        widget=forms.PasswordInput(attrs={"class": "form-control"}, render_value=True)  # 密码标签
    )
    code = forms.CharField(
        label="验证码",
        widget=forms.TextInput,
        required=True
    )
    # 钩子函数，给密码加密，从而可以使数据与后端密码比较
    def clean_password(self):
        pwd = self.cleaned_data.get("password")
        return md5(pwd)
# # ModelForm则是从数据库中拿字段,去数据库拿安全性差些
# class LoginModelForm(forms.ModelForm):
#     class Meta:
#         model = models.VIP
#         fields = ['username', 'password']
"""
登录
"""
def login(request):
    if request.method == "GET":
        form = LoginForm()
        return render(request, 'login.html', {'form': form})
    form = LoginForm(data=request.POST)
    if form.is_valid():
        # form.cleaned_data获取前端用户输入的值（用户名和密码、验证码）
        # print(form.cleaned_data)  # 验证成功，获取到的用户名和密码,因为form与modelForm不同，form不与数据库关联不可以直接写入数据库
        # 验证码校验，并使用pop（）把code验证码的值剔除掉，从而保证其不会被存储入数据库
        user_input_code = form.cleaned_data['code']  # 用户填写的验证码
        code = request.session.get('image_code', "")
        if code == user_input_code:
            form.add_error("code", "验证码错误")
            return render(request, 'login.html', {'form': form})
        # 去数据库校验用户名和密码是否正确
        # 因为上面有个钩子函数，给form.cleaned_data方法加密了，所以这个获取的也是加密的密码
        first = models.VIP.objects.filter(**form.cleaned_data).first()
        # first = models.VIP.objects.filter(username="xxx", password="xxx").first()  ，如上代替具体见搜索手机号详解,只有字典可以这么用
        if not first:
            form.add_error("password", "用户密码错误")  # 给password字段主动添加错误，password从上面18行创建字段表单获取的
            # 存储session到数据库django_session表中自动创建的，也就是用户cookie的凭证，使用cookie的时候得用session来辨别用户
        request.session["info"] = {'username': first.username}  # 获取用户id和username存储到session中，来当用户凭证,这里只存储username
        # 设置session存活时间，7天内免登录
        request.session.set_expiry(60 * 60 * 24 * 7)
        return redirect("/VIP/list/")
    return render(request, 'login.html', {'form': form})
"""
验证码
"""
def image(request):
    # 调用pillow函数，生成图片
    img, code_string = check_code()
    # 将生成的验证码写入session中，方便后续用于校验
    request.session['image_code'] = code_string
    # 给Session设置60秒超时，即验证码有效时间只有60s
    request.session.set_expiry(60)
    stream = BytesIO()  # 在内存中创建一个文件
    img.save(stream, 'png')  # 将生成的img文件写入，文件中
    return HttpResponse(stream.getvalue())

九、Ajax异步请求

发送局部请求

1、ajax发送get请求

前端页面

{% extends 'layout.html' %}
{% block content %}
    
        任务管理
        示例1
        
    
{% endblock %}
{% block js %}
 {% endblock %}
$.ajax({
    url: '/task/ajax/',   // 发送的地址
    type: "get",
    data: {
        n1: 123,
        n2: 456
    },
    success: function (res) {
        console.log(res);
    }
})
 {% endblock %}

后端接收请求

from django.shortcuts import render, HttpResponse
def task_ajax(request):
    print(request.GET)
    return HttpResponse("成功了")

urls.py

 # ajax请求
    path('ajax/task/', ajax.task_ajax)

2、ajax发送post请求

前端页面

{% extends 'layout.html' %}
{% block content %}
    
        任务管理
        示例1
        
    
{% endblock %}
{% block js %}
 {% endblock %}

后端

from django.shortcuts import render, HttpResponse
from django.views.decorators.csrf import csrf_exempt
@csrf_exempt
def task_ajax(request):
    print(request.GET)
    print(request.POST)
    return HttpResponse("成功了")

urls.py

 # ajax请求
    path('ajax/task/', ajax.task_ajax)

3、绑定事件

前端

{% extends 'layout.html' %}
{% block content %}
    
        任务管理
        示例1
        
    
{% endblock %}
{% block js %}
    
{% endblock %}

4、ajax的返回值

返回值是json格式

{% extends 'layout.html' %}
{% block content %}
    
        任务管理
        示例1
        
    
{% endblock %}
{% block js %}
    
{% endblock %}

后端

from django.shortcuts import render, redirect, HttpResponse
from django.views.decorators.csrf import csrf_exempt
import json
from django.http import JsonResponse
def task_list(request):
    """ 任务列表 """
    return render(request, "task_list.html")
@csrf_exempt
def task_ajax(request):
    print(request.GET)
    print(request.POST)
    data_dict = {"status": True, 'data': [11, 22, 33, 44]}
    return HttpResponse(json.dumps(data_dict))  # 将数据返回去前端页面
    # return JsonResponse(data_dict)  # django带的方法可以简化如上返回代码，需要导包

urls.py

 # ajax请求
    path('ajax/task/', ajax.task_ajax)

5、测试代码

task.html

{% extends 'layout.html' %}
{% block content %}
        
        Ajax学习
        示例2
        
        
        
        示例3

{% endblock %} {% block js %} {% endblock %}

ajax.py

from django.shortcuts import render, redirect, HttpResponse
from django.views.decorators.csrf import csrf_exempt
import json
from django.http import JsonResponse
def task_list(request):
    """ 任务列表 """
    return render(request, "task_list.html")
@csrf_exempt
def task_ajax(request):
    print(request.GET)
    print(request.POST)
    data_dict = {"status": True, 'data': [11, 22, 33, 44]}
    return HttpResponse(json.dumps(data_dict))  # 将数据返回去前端页面
    # return JsonResponse(data_dict)  # django带的方法可以简化如上返回代码，需要导包

urls.py

# ajax请求，注意导入ajax.py包，views文件夹中
    path('ajax/task/', ajax.task_ajax),
    path('ajax/list/', ajax.task_list),

十、回顾与梳理

知识点的回顾：

安装Djangox
```
pip install django
```
创建Django项目
```
>>> django-admin startproject mysite
```
注意：Pycharm可以创建。如果用Pycharm创建，记得settings.py中的DIR templates 删除。

创建app & 注册

>>>python manage.py startapp app01
>>>python manage.py startapp app02
>>>python manage.py startapp app03

INSTALLED_APPS = [
    ...
    'app01.apps.App01Config'
]

注意：否则app下的models.py写类时，无法在数据库中创建表。

配置静态文件路径 & 模板的路径（放在app目录下）。

static、templates、utils

配置数据库相关操作（MySQL）

第三方模块（django3版本）
```
pip install mysqlclient
```

自己先去MySQL创建一个数据库。

mysql -u root -p
CREATE DATABASE djangodemo3 CHARACTER SET utf8 COLLATE utf8_general_ci;  utf-8后面是排列规则

配置数据库连接settings.py

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'djangoDemo3',  # 数据库名字
        'USER': 'root',
        'PASSWORD': '1234',
        'HOST': '127.0.0.1',  # 哪台机器安装了MySQL
        'PORT': 3306,
    }
}

在app下的models.py中编写

from django.db import models
class Admin(models.Model):
    """ 管理员 """
    username = models.CharField(verbose_name="用户名", max_length=32)
    password = models.CharField(verbose_name="密码", max_length=64)
    def __str__(self):
        return self.username
    
class Department(models.Model):
    """ 部门表 """
    title = models.CharField(verbose_name='标题', max_length=32)
    def __str__(self):
        return self.title

执行两个命令：

>>>python manange.py makemigrations
>>>python manange.py migrate

在 urls.py ，路由（ URL 和函数的对应关系）。
在views.py，视图函数，编写业务逻辑。
templates目录，编写HTML模板（含有模板语法、继承、{% static 'xx'%}）
ModelForm & Form组件，在我们开发增删改查功能。
- 生成HTML标签（生成默认值）
- 请求数据进行校验。
- 保存到数据库（ModelForm）
- 获取错误信息。
- Cookie和Session，用户登录信息保存起来。
- 中间件，基于中间件实现用户认证，基于：process_request。
- ORM操作
```
models.User.objects.filter(id="xxx")
models.User.objects.filter(id="xxx").order_by("-id")
```
- 分页组件。

上一篇：mysql 中 cast 函数用法

下一篇：Mybatis - 常用 SQL 语句设计思路及具体实现 - 数据存在则更新，不存在则插入、批量更新、批量插入、连表查询 + - 字段加减法