Django框架知识
目录
一.数据的增删改查
1.大致流程
用户列表的展示
修改数据的逻辑分析
删除功能的分析
2.如何查询数据
3.数据的增加
4.用户操作数据的更改
（1）编辑功能
（2）删除功能
二.表关系的建立
1.表关系相关知识
2.总结
（1）ForeignKey（多对一）
（2）ManyToManyField（多对多）
（3）OneToOneField（一对一）
（4）ManyToManyField 和 OneToOneField自动加id后缀
一.数据的增删改查
1.大致流程
-
用户列表的展示
把数据表中的用户数据都给查询出来展示在页面上
-
修改数据的逻辑分析
- 先确定修改哪条记录 ------> 怎么确定修改哪条记录
- 通过什么字段可以确定唯一一条记录
- 在后端接收主键id值，然后根据这个id值再去表中查询数据
- 然后把查询的数据渲染到页面中，然后在进行修改
- 把修改之后的表单提交到后端，再做修改
-
删除功能的分析
- 给删除按钮加一个链接，携带当前记录的id值
- 后端要接收这个主键id值
- 后端直接执行删除操作
2.如何查询数据
from django.shortcuts import render, HttpResponse, redirect
from app01 import models
# Create your views here.
def login(request):
'''
get 请求和 post 请求应该具有不同的处理机制
:param request:
:return:
'''
# （1） 获取 请求方式 并且是全大写字符串
if request.method == "POST":
# 获取用户数据
data = request.POST
# print(data)
'''
# get 只会获取列表最后一个元素
username = data.get('username')
password = data.get('password')
hobby = data.get('hobby')
'''
# # getlist 获取所有值
# username = data.getlist('username')
# password = data.getlist('password')
# hobby = data.getlist('hobby')
#
# print(username, password, hobby)
# --------------------------
# 获取用户输入的用户名和密码
username = data.get('username')
password = data.get('password')
# 向数据库查询数据
res = models.User.objects.filter(username=username)
print(res)
# 返回的是[数据对象1，数据对象2]
# 数据对象支持索引取值
user_obj = res[0]
print(user_obj.username)
print(user_obj.password)
# 获取 get 请求 网址后边携带的请求参数
data = request.GET
# 处理请求数据 同 POST
return render(request, 'login.html')
# 向数据库查询数据
res = models.User.objects.filter(username=username)
print(res)
# 返回的是[数据对象1，数据对象2]
# 数据对象支持索引取值
user_obj = res[0]
print(user_obj.username)
# dream
print(user_obj.password)
# 521
- 返回值类似于列表套对象
- 支持索引取值，支持切片，但是不支持负数索引取值
- 不推荐索引取值
3.数据的增加
def register(request):
# 先给用户返回一个注册页面
if request.method == 'POST':
data = request.POST
username = data.get('username')
password = data.get('password')
# # 直接获取用户输入的数据存储进数据库
# # （1）第一种直接添加
# res = models.User.objects.create(username=username, password=password)
# # 返回值就是当前被创建的对象本身
# print(res)
# （2） 第二种 创建类对象
user_obj = models.User(username=username, password=password)
# 保存数据
user_obj.save()
return render(request, 'register.html')
4.用户操作数据的更改
- 先从数据库中将数据全部展示到前端，然后添加两个按钮，一个编辑，一个删除
（1）编辑功能
点击编辑按钮，向后端发送编辑数据的请求
- 如何告诉用户想要编辑哪条数据
- 将编辑按钮所在的信息的主键值发送给后端
- 在URL的？中携带参数
- 后端拿到用户想要编辑的数据对象，展示到前端页面供用户查看和编辑
查询数据
def resetdata(request):
# 查询用户表内的所有数据
# 方式一
# data = models.User.objects.filter()
# 方式二
user_queryset = models.User.objects.all()
return render(request, 'resetdata.html', locals())用户数据展示
{% for user_obj in user_queryset %}
{{ user_obj.id }}
{{ user_obj.username }}
{{ user_obj.password }}
编辑
删除
{% endfor %}
编辑数据
def edit_user(request):
# 获取URL后面拼接的用户ID
edit_id = request.GET.get('user_id')
# 查询当前用户想要编辑的用户对象
edit_obj = models.User.objects.filter(id=edit_id).first()
# 编辑用户
if request.method == 'POST':
username = request.POST.get('username')
password = request.POST.get('password')
# 在数据库中修改数据
# 修改数据方式一
# 将 filter 查询出的列表内的所有的对象全部更新 ---- 批量更新操作
# 只修改被修改的字段
# models.User.objects.filter(id=edit_id).update(username=username, password=password)
# 编辑完后跳转到展示与用户数据页面
# 修改数据方式二
# 局部更新
# 当字段特别多的时候，效率会非常低
# 从头到尾将数据的所有字段更新一遍，无论字段是否被改变
edit_obj.username = username
edit_obj.password = password
edit_obj.save()
return redirect('/resetdata/')
# 将数据对象展示到页面上
return render(request, 'edituser.html', locals())
用户数据展示页面
{% load static %}
Title
{#拿到用户数据#}
{{ user_queryset }}
用户数据展示
编辑用户数据页面
{% load static %}
Title
信息编辑功能
路由层
"""day02 URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/3.2/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import path
from app01 import views
urlpatterns = [
path('admin/', admin.site.urls),
path('login/', views.login),
path('register/', views.register),
# 查询所有用户信息
path('resetdata/', views.resetdata),
# 编辑用户信息
path('edit_user/', views.edit_user),
]
（2）删除功能
- 跟编辑功能逻辑类似
删除功能
def del_user(request):
# 获取用户想要删除的用户ID
del_user_id = request.GET.get('user_id')
# 拿到用户对象并删除
# 批量删除
models.User.objects.filter(id=del_user_id).delete()
# 删除成功，跳转到展示页面
return redirect('/resetdata/')路由层
"""day02 URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/3.2/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import path
from app01 import views
urlpatterns = [
path('admin/', admin.site.urls),
path('login/', views.login),
path('register/', views.register),
# 查询所有用户信息
path('resetdata/', views.resetdata),
# 编辑用户信息
path('edit_user/', views.edit_user),
# 删除用户数据
path('del_user/', views.del_user),
]
- 真正的删除数据操作需要二次确认
- 删除数据，内部其实不是真正的删除数据
- 我们会给数据添加一个删除字段来表示数据是否被删除了，如果数据被删除了，仅仅只是修改字段的状态值
二.表关系的建立
1.表关系相关知识
- 表与表之间的关系
- 一对一
- 一对多
- 多对多
- 判断表关系的方法
- 换位思考
以图书和出版社关系为例
- 图书和出版社是一对多的关系
- 外键建在多的一方，即图书
- 图书和作者是多对多的关系
- 需要创建第三张表
- 作者与作者详情表是一对一的关系
图书表
class Book(models.Model):
# 默认创建主键字段（可忽略不写）
# 创建字段 ：书籍标题
title = models.CharField(max_length=32, verbose_name="书籍名称")
# 创建字段 ：书籍价格
# max_digits ： 小数一共几位
# decimal_places ：小数点后几位
price = models.DecimalField(max_digits=8, decimal_places=2, verbose_name="书籍价格")
'''
图书和出版社是一对多，并且书是多的一方 ， 所以外键字段放在书表里面
'''
# to_fields : 默认不写就是和被关联表的id值进行关联
# on_delete=models.CASCADE : 级联更新
'''
如果字段对应的是 ForeignKey 那么 ORM 会自动在字段后面 加 id 变成 publish_id
如果自己 加了 id 即 publish_id ，ORM 仍然会帮我们在后面 加 _id 变成 publish_id_id
后面在使用 ForeignKey 时 ，不建议 自己主动加id
'''
publish = models.ForeignKey(to='Publisher', on_delete=models.CASCADE)
'''
图书和作者是多对多的关系 外键建在任意一方即可 ，但是推荐建在查询频率较高的一方
'''
# authors : 是一个虚拟字段，主要是用来告诉 ORM 数据表和作者表是多对多的关系
# 让 ORM 来帮助我们自动创建第三张表
authors = models.ManyToManyField(to='Author')出版社表
class Publisher(models.Model):
# 默认创建主键字段（可忽略不写）
# 创建字段 ： 出版社名字
pub_name = models.CharField(max_length=32, verbose_name="出版社名称")
# 创建字段 ： 出版社地址’
pub_addr = models.CharField(max_length=32, verbose_name="出版社地址")作者表
class Author(models.Model):
# 默认创建主键字段（可忽略不写）
# 创建字段 ： 作者名字
aut_name = models.CharField(max_length=32, verbose_name="作者名字")
# 创建字段 ： 作者年龄
aut_age = models.IntegerField(verbose_name="作者年龄")
'''
作者与作者详情之间是一对一的关系， 外键字段建在任意一方即可，但是推荐建在查询频率较高的一方
'''
'''
如果字段对应的是 OneToOneField 那么 ORM 会自动在字段后面 加 id
后面在使用 OneToOneField 时 ，不建议 自己主动加id
'''
author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)
作者详情表
class AuthorDetail(models.Model):
# 默认创建主键字段（可忽略不写）
# 创建字段 ： 作者电话
# 考虑到电话的长度问题，建议用 BigIntegerField 或者 直接 用 CharField存成字符串
aut_phone = models.BigIntegerField(verbose_name="作者电话")
# 创建字段 ： 作者的住址
aut_addr = models.CharField(max_length=32, verbose_name="作者住址")
配置文件：setting.py
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'day10', # 指定数据库
'USER': 'root', # 自己的用户名
'PASSWORD': '1314521', # 自己的密码
'HOST': '127.0.0.1',
'PORT': 3306,
'CHARSET': 'utf8',
}
}初始化文件：__init__.py
import pymysql
pymysql.install_as_MySQLdb()终端重载数据库
python39 manage.py makemigrations
python39 manage.py migrate2.总结
（1）ForeignKey（多对一）
- 是Django中的一个字段类型，用于建立模型间的多对一关系，通过在一个模型中使用ForeignKey字段，可以将其与另一个模型的主键关联起来，表示多个实例对应一个实例关系
- 比如
- 一个博客系统中，可以有两个模型：作者（Author）和文章（Post）
- 一个作者可以写多篇文章，但一篇文章只能对应一个作者
- 这时，可以在Post模型中定义一个ForeignKey字段，指向Author模型：
class Author(models.Model):
name = models.CharField(max_length=50)
class Post(models.Model):
title = models.CharField(max_length=100)
content = models.TextField()
author = models.ForeignKey(Author, on_delete=models.CASCADE)
（2）ManyToManyField（多对多）
- 也是Django中的一个字段类型，用于建立模型间的多对多关系
- 通过使用ManyToManyField字段，可以在两个模型之间创建一个多对多的关联，表示多个实例之间互相对应的关系
- 继续以博客系统为例
- 在一个标签（Tag）模型和文章（Post）模型之间存在多对多的关系
- 一篇文章可以对应多个标签，一个标签也可以对应多篇文章
- 这时，可以在Post模型和Tag模型中分别定义ManyToManyField字段：
class Tag(models.Model):
name = models.CharField(max_length=50)
class Post(models.Model):
title = models.CharField(max_length=100)
content = models.TextField()
tags = models.ManyToManyField(Tag)
（3）OneToOneField（一对一）
- 是Django中的另一个字段类型，用于建立模型间的一对一关系
- 通过使用OneToOneField字段，可以在两个模型之间创建一个一对一的关联，表示一个实例对应另一个实例的关系
- 例如
- 一个用户（User）模型和一个用户资料（Profile）模型之间有一对一的关系
- 每个用户只有一个对应的用户资料
- 可以在Profile模型中定义一个OneToOneField字段，在User模型上进行关联：
from django.contrib.auth.models import User
class Profile(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
bio = models.TextField()
location = models.CharField(max_length=50)- 上述代码中，Profile模型中的user字段是一个OneToOneField字段，它以User模型为参数来指定一对一的关联，这样就可以让每个user实例对应一个Profile实例，方便扩展用户信息
（4）ManyToManyField 和 OneToOneField自动加id后缀
如果字段对应的是ForeignKey/OneToOneField那么ORM会自动在字段后面加id变成publish_id如果自己加了id，ORM仍会在字段后再加上id
- 实际上，ManyToManyField和OneToOneField字段在数据库中会自动创建相关的外键
- 并非在字段后加上'id'后缀
- 这些外键字段名的生成方式取决于Django的命名规则和相关模型的名称
对于ManyToMany字段，Django会默认使用源模型（即声明ManyToManyField的模型）的名称和目标模型（关联的模型）的名称来生成中间表的名称，并在其中创建外键
- 例如，如果有两个模型：Author和Book，并且在Author模型中有一个books字段声明为ManyTomanyField类型：
from django.contrib.auth.models import User
class Profile(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
bio = models.TextField()
location = models.CharField(max_length=50)- Django将在Profile模型中创建一个名为user_id的外键字段，用于与User模型进行关联
总结来说，ManyToManyField和OneToOneField字段在数据库中会生成相关的外键字段，并且没有自动加上id后缀
其他与这些字段相关的命名规则和约定主要取决于使用Django的默认行为或者通过特定参数进行自定义