观看视频记录

Django 是一个用于构建 Web 应用程序的高级 Python Web 框架



## 1. 简介

Django 版本要对应的 Python 版本

```
1.8	 2.7, 3.2 , 3.3, 3.4, 3.5
1.9, 1.10	2.7, 3.4, 3.5
1.11	 2.7, 3.4, 3.5, 3.6
2.0	 3.4, 3.5, 3.6, 3.7
2.1, 2.2	3.5, 3.6, 3.7
3.2	 3.6, 3.7, 3.8, 3.9, 3.10
4.0	 3.8, 3.9, 3.10
4.1	 3.8, 3.9, 3.10, 3.11 (added in 4.1.3)
4.2	 3.8, 3.9, 3.10, 3.11, 3.12 (added in 4.2.8)
```
## 2. 修改配置文件
### 2.1 修改配置文件的路径

```
TEMPLATES = [
 {
 'BACKEND': 'django.template.backends.django.DjangoTemplates',
 'DIRS': [os.path.join(BASE_DIR, 'templates')], ## 修改前端模板文件位置
 'APP_DIRS': True,
 'OPTIONS': {
 'context_processors': [
 'django.template.context_processors.debug',
 'django.template.context_processors.request',
 'django.contrib.auth.context_processors.auth',
 'django.contrib.messages.context_processors.messages',
 ],
 },
 },
]
```
### 2.2 修改配置文件添加app的注册地址
TestModel 为app的名称

```
INSTALLED_APPS = (
 'django.contrib.admin',
 'django.contrib.auth',
 'django.contrib.contenttypes',
 'django.contrib.sessions',
 'django.contrib.messages',
 'django.contrib.staticfiles',
 'TestModel', # 添加TestModel(即创建的app的名称)
)
```

## 3. 配置数据库
### 3.1 修改配置文件的数据库配置
注销原有数据库，修改为现在使用的数据库配置

```
DATABASES = { 
 'default': 
 { 
 'ENGINE': 'django.db.backends.mysql', # 数据库引擎
 'NAME': 'runoob', # 数据库名称
 'HOST': '127.0.0.1', # 数据库地址，本机 ip 地址 127.0.0.1 
 'PORT': 3306, # 端口 
 'USER': 'root', # 数据库用户名
 'PASSWORD': '123456', # 数据库密码
 } 
}
```
### 3.2 修改TestModel/models.py 文件

```
from django.db import models
 
class Test(models.Model):
 name = models.CharField(max_length=20)
```
### 3.3 数据库的操作方式
#### 3.31 添加数据
添加数据需要先创建对象，然后再执行 save 函数，相当于SQL中的INSERT

```
from django.http import HttpResponse
from TestModel.models import Test
 
# 数据库操作
def testdb(request):
 test1 = Test(name='runoob')
 test1.save()
 return HttpResponse("数据添加成功！")
```

#### 3.32 获取数据

```
from django.http import HttpResponse
from TestModel.models import Test
 
# 数据库操作
def testdb(request):
 # 初始化
 response = ""
 response1 = ""
 
 
 # 通过objects这个模型管理器的all()获得所有数据行，相当于SQL中的SELECT * FROM
 list = Test.objects.all()
 
 # filter相当于SQL中的WHERE，可设置条件过滤结果
 response2 = Test.objects.filter(id=1) 
 
 # 获取单个对象
 response3 = Test.objects.get(id=1) 
 
 # 限制返回的数据 相当于 SQL 中的 OFFSET 0 LIMIT 2;
 Test.objects.order_by('name')[0:2]
 
 #数据排序
 Test.objects.order_by("id")
 
 # 上面的方法可以连锁使用
 Test.objects.filter(name="runoob").order_by("id")
 
 # 输出所有数据
 for var in list:
 response1 += var.name + " "
 response = response1
 return HttpResponse("" + response + "")
```
#### 3.33 更新数据
修改数据可以使用 save() 或 update()

```
from django.http import HttpResponse
from TestModel.models import Test
 
# 数据库操作
def testdb(request):
 # 修改其中一个id=1的name字段，再save，相当于SQL中的UPDATE
 test1 = Test.objects.get(id=1)
 test1.name = 'Google'
 test1.save()
 
 # 另外一种方式
 #Test.objects.filter(id=1).update(name='Google')
 
 # 修改所有的列
 # Test.objects.all().update(name='Google')
 
 return HttpResponse("修改成功")
```
#### 3.34 删除数据
删除数据库中的对象只需调用该对象的delete()方法即可

```
from django.http import HttpResponse
from TestModel.models import Test

# 数据库操作
def testdb(request):
 # 删除id=1的数据
 test1 = Test.objects.get(id=1)
 test1.delete()
 
 # 另外一种方式
 # Test.objects.filter(id=1).delete()
 
 # 删除所有数据
 # Test.objects.all().delete()
 
 return HttpResponse("删除成功")
```
 
### 3.4 数据库操作实例 --ignore

暂无

## 4. 配置路由
### 4.1 配置路由路径
可以使用通配符

```
from django.urls import re_path # 用re_path 需要引入 
urlpatterns = [ 
 path('admin/', admin.site.urls), 
 path('index/', views.index), # 普通路径 
]
```
### 4.2 GET&POST获取数据

```
from django.shortcuts import render,redirect,HttpResponse

def web(request):
 if request.method == 'GET':
 name = request.GET.get('name')
 password = request.GET.get('password')
 
 if request.method == 'POST':
 name = request.POST.get('name')
 password = request.POST.get('password')
```
 
### 4.3 返回数据格式(三种方式) --ignore

```
def web_render(request):
	return render(request, 'shop/user_reg.html', {"form_obj": form_obj})

def web_redirect(request):
	return redirect('/your_url/{}/'.format(post.id))

def web_HttpResponse(request):
	return HttpResponse("hello")
```
### 4.4 serializers序列化
我们知道前后端常用json数据结构交互， 在后端我们常想把一个对象返回给前端，但是json序列化是不能序列化对象（不过可以添加序列化参数encoder序列化原理和序列化组件差不多需要自己定义序列化类和返回的结构），所以就有了我们的序列化组件，可以自定义特定结构把对象序列化返回给前端，同时可以对前端传入的参数进行数据校验等功能。

```
from django.core import serializers #序列化

def web_login(request):
 if request.method == 'GET':
 page = int(request.GET.get('page'))
 result = serializers.serialize("json", models.ComicMain.objects.filter(id__range=[page,page+12]).all())
 nums = models.ComicMain.objects.count()
 # 登录成功
 backdata["code"] = 200
 backdata["msg"] = "登录成功"
 backdata["nums"] = nums
 backdata["data"] = result
 return HttpResponse(json.dumps(backdata))
```
### 4.5 csrf 配置使用 --ignore
## 5. Django Admin 管理工具
### 5.1 注册django admin工具
Django 提供了基于 web 的管理工具,在项目的 settings.py 中的 INSTALLED_APPS 查看

```
INSTALLED_APPS = (
 'django.contrib.admin',
 'django.contrib.auth',
 'django.contrib.contenttypes',
 'django.contrib.sessions',
 'django.contrib.messages',
 'django.contrib.staticfiles',
)
```
### 5.2 激活管理工具
通常我们在生成项目时会在 urls.py 中自动设置好，我们只需去掉注释即可
### 5.3 使用管理工具
启动开发服务器，然后在浏览器中访问 http://127.0.0.1:8000/admin/
### 5.4 创建超级用户
python manage.py createsuperuser

Username (leave blank to use 'root'): admin

Email address: admin@runoob.com

Password:

Password (again):

Superuser created successfully.
### 5.5 admin注册数据模型
为了让 admin 界面管理某个数据模型，我们需要先注册该数据模型到 admin。比如，我们之前在 TestModel 中已经创建了模型 Test 。修改 TestModel/admin.py

```
from django.contrib import admin
from TestModel.models import Test

# Register your models here.
admin.site.register(Test)
```
## 6. Django Form 组件
Django Form 组件用于对页面进行初始化，生成 HTML 标签，此外还可以对用户提交的数据进行校验（显示错误信息）。
报错信息显示顺序：

● 先显示字段属性中的错误信息，然后再显示局部钩子的错误信息。

● 若显示了字段属性的错误信息，就不会显示局部钩子的错误信息。

● 若有全局钩子，则全局钩子是等所有的数据都校验完，才开始进行校验，并且全局钩子的错误信息一定会显示。
### 6.1 导入 forms

```
from django import forms
```
### 6.2 使用 forms --ignore
## 7. Django 用户认证（Auth）组件
### 7.1 导入auth 

```
# 认证模块
from django.contrib import auth
# 对应数据库
from django.contrib.auth.models import User
```


### 7.2 使用auth --ignore
## 8. Django cookie 与 session
### 8.1 Cookie教程
#### 8.11 设置 cookie

```
rep = HttpResponse(json.dumps(backdata))
rep.set_cookie(key,value,...) 
rep.set_cookie("_id",encryptdata,expires=3600)
rep.set_signed_cookie(key,value,salt='加密盐',...)
```

:::tip{title="提示"}
tip: cookies要设置过期时间
:::
#### 8.12 获取 cookie
request.COOKIES.get(key)
#### 8.13 删除 cookie

```
rep =HttpResponse || render || redirect 
rep.delete_cookie(key)
8.14 操作cookie实例
def login(request):
 if request.method == "GET":
 return render(request, "login.html")
 username = request.POST.get("username")
 password = request.POST.get("pwd")

 user_obj = models.UserInfo.objects.filter(username=username, password=password).first()
 print(user_obj.username)

 if not user_obj:
 return redirect("/login/")
 else:
 rep = redirect("/index/")
 rep.set_cookie("is_login", True)
 return rep
 
def index(request):
 print(request.COOKIES.get('is_login'))
 status = request.COOKIES.get('is_login') # 收到浏览器的再次请求,判断浏览器携带的cookie是不是登录成功的时候响应的 cookie
 if not status:
 return redirect('/login/')
 return render(request, "index.html")


def logout(request):
 rep = redirect('/login/')
 rep.delete_cookie("is_login")
 return rep # 点击注销后执行,删除cookie,不再保存用户状态，并弹到登录页面
 
def order(request):
 print(request.COOKIES.get('is_login'))
 status = request.COOKIES.get('is_login')
 if not status:
 return redirect('/login/')
 return render(request, "order.html")
```
### 8.2 Session教程
#### 8.21 session 设置

```
request.session["key"] = value
request.session.set_expiry(3600) #设置过期时间
```

:::tip{title="提示"}
tip: session要设置过期时间
:::
#### 8.22 session 获取

```
request.session.get('key')
```
#### 8.23 session 删除
删除整条记录（包括 session_key、session_data、expire_date 三个字段）：

```
request.session.flush()
```
删除 session_data 里的其中一组键值对：

```
del request.session["key"]
```
## 9.Django 中间件
Django 中间件是修改 Django request 或者 response 对象的钩子，可以理解为是介于 HttpRequest 与 HttpResponse 处理之间的一道处理过程。

Django 中间件作用：

● 修改请求，即传送到 view 中的 HttpRequest 对象。

● 修改响应，即 view 返回的 HttpResponse 对象。

中间件组件配置在 settings.py 文件的 MIDDLEWARE 选项列表中。
配置中的每个字符串选项都是一个类，也就是一个中间件。

### 9.1 Django 默认的中间件配置

```
MIDDLEWARE = [
 'django.middleware.security.SecurityMiddleware',
 'django.contrib.sessions.middleware.SessionMiddleware',
 'django.middleware.common.CommonMiddleware',
 'django.middleware.csrf.CsrfViewMiddleware',
 'django.contrib.auth.middleware.AuthenticationMiddleware',
 'django.contrib.messages.middleware.MessageMiddleware',
 'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
```
### 9.2 自定义中间件
中间件可以定义四个方法，分别是：

process_request(self,request)

process_view(self, request, view_func, view_args, view_kwargs)

process_exception(self, request, exception)

process_response(self, request, response)
#### 9.21 自定义中间件的第一步
在 app 目录下新建一个 py 文件，名字自定义，并在该 py 文件中导入 

```
MiddlewareMixin：
from django.utils.deprecation import MiddlewareMixin
```
#### 9.22 自定义中间件的第二步
自定义的中间件类，要继承父类 MiddlewareMixin:

```
class MD1(MiddlewareMixin): 
 pass
```
#### 9.23 在settings.py 中的 MIDDLEWARE 里注册自定义的中间件类

```
MIDDLEWARE = [
 'django.middleware.security.SecurityMiddleware',
 'django.contrib.sessions.middleware.SessionMiddleware',
 'django.middleware.common.CommonMiddleware',
 'django.middleware.csrf.CsrfViewMiddleware',
 'django.contrib.auth.middleware.AuthenticationMiddleware',
 'django.contrib.messages.middleware.MessageMiddleware',
 'django.middleware.clickjacking.XFrameOptionsMiddleware',
 
 'app01.middlewares.MD1',
]
```
#### 9.24 自定义的中间件继承的方法

```
class MD1(MiddlewareMixin):
 def process_request(self, request):
 print("md1 process_request 方法。", id(request)) #在视图之前执行

 def process_response(self,request, response): :#基于请求响应
 print("md1 process_response 方法！", id(request)) #在视图之后
 return response

 def process_view(self,request, view_func, view_args, view_kwargs):
 print("md1 process_view 方法！") #在视图之前执行 顺序执行
 #return view_func(request)


 def process_exception(self, request, exception):#引发错误 才会触发这个方法
 print("md1 process_exception 方法！") 
 # return HttpResponse(exception) #返回错误信息
```

django的基础教程

django设置文件在projects/projects/目录下的settings.py中，以后但凡说到设置文件，都是指这个文件



## django配置文件（全）

```
# 导入Path包
from pathlib import Path 
# 将常量BASE_DIR的路径设置为settings.py的上级的再上一级路径，简单来讲就是项目的根目录
BASE_DIR = Path(__file__).resolve().parent.parent
# 这个就是一个密钥，正常的项目是需要保密的
SECRET_KEY = 'django-insecure-dwoni%ns411f*3%=ch&dyz$@%o3(1k^!5n5affbtqn3bxxmw5v'
# DEBUG常量是用于开启、关闭调试模式的，开始过程中用True就行，一旦布置后则需要设置为False，不然会泄露项目的关键信息。
DEBUG = True
# 默认是一个空列表，一个代表这个 Django 网站可以服务的主机／域名的字符串列表。如果 DEBUG 为 False，还需要正确设置 ALLOWED_HOSTS 配置。否则，所有的请求都会以 “Bad Request (400) ” 返回。
ALLOWED_HOSTS = []

# 这里是应用的列表，表示已经启用的应用，这里最后一行加上刚刚我们新建的应用pm。

INSTALLED_APPS = [
 'django.contrib.admin',
 'django.contrib.auth',
 'django.contrib.contenttypes',
 'django.contrib.sessions',
 'django.contrib.messages',
 'django.contrib.staticfiles',
 'pm',
]
# 中间件，可以暂时先不用管
MIDDLEWARE = [
 'django.middleware.security.SecurityMiddleware',
 'django.contrib.sessions.middleware.SessionMiddleware',
 'django.middleware.common.CommonMiddleware',
 'django.middleware.csrf.CsrfViewMiddleware',
 'django.contrib.auth.middleware.AuthenticationMiddleware',
 'django.contrib.messages.middleware.MessageMiddleware',
 'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

# 主路由，这里指的就是projects/projects/urls.py文件
ROOT_URLCONF = 'projects.urls'
# 模板引擎，这里默认就是Django的模板引擎，其中DIRS表示会搜索的路径，默认为根目录下的templates文件夹，APP_DIRS设置为True,表示会搜索app目录下的templates文件夹。
TEMPLATES = [
 {
 'BACKEND': 'django.template.backends.django.DjangoTemplates',
 'DIRS': [BASE_DIR / 'templates']
 ,
 'APP_DIRS': True,
 'OPTIONS': {
 'context_processors': [
 'django.template.context_processors.debug',
 'django.template.context_processors.request',
 'django.contrib.auth.context_processors.auth',
 'django.contrib.messages.context_processors.messages',
 ],
 },
 },
]
# WSGI服务器，指的是projects/projects/wsgi.py文件中的application,可以打开这个文件看看里面的内容，不要动就好了。
WSGI_APPLICATION = 'projects.wsgi.application'

# 下面是数据库的设置，这里直接改成我们前面设置好的mysql数据库，按如下配置就可以了，依据是数据库引擎，名称，用户名，密码，主机，端口，按前面配置的来就行。
DATABASES = {
 'default': {
 'ENGINE': 'django.db.backends.mysql',
 'NAME': 'projects',
 'USER':'projects',
 'PASSWORD':'Project123.',
 'HOST':'localhost',
 'PORT':'3306',
 }
}


# 用于检查用户密码强度的验证器列表。

AUTH_PASSWORD_VALIDATORS = [
 {
 'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
 },
 {
 'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
 },
 {
 'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
 },
 {
 'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
 },
]


# 下面是语言和时区设置，语言直接设置为zh-hans，就是中文，时区改为上海
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'Asia/Shanghai'

# 用于指定是否应该启用 Django 的翻译系统。
USE_I18N = True
# 用于指定 Django 是否默认使用时区感知。
USE_TZ = True

# 静态文件的设置
# 指静态文件的网址路径，也就是URL，本例中则为http://127.0.0.1:8000/static/
STATIC_URL = 'static/' 
# django默认将会从每个app的static文件夹中查找，找到就停止，有几个设置项，一个是STATICFILES_DIRS，如果设置后，则优先查询这个设置项的静态文件，再查找app里的静态文件，但如果需要布置的话，则需要配置STATIC_ROOT,再通过collectstatic将所有的静态文件搜集到这个STATIC_ROOT配置的目录中去。

# 这里增加二项设置
# 处理从 MEDIA_ROOT 提供的媒体的 URL，用于管理存储文件，本例中则为http://127.0.0.1:8000/media/
MEDIA_URL='media/'
# 保存用户上传的文件目录的绝对文件系统路径。
MEDIA_ROOT= BASE_DIR / 'media'

# 默认的主键字段类型，用于没有带有 primary_key=True 字段的模型。
DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
```

django 配置文件

Django是一个高级的Python Web框架，它鼓励快速开发、干净且实用的设计。



- [Django官方文档](https://docs.djangoproject.com/)

在安装 Django 前，系统需要已经安装了 Python 的开发环境。

## 1、Django 安装

```
pip install Django
```

安装完成后，你可以通过运行以下命令验证 Django 是否成功安装

```
python3 -m django --version
```
如果一切顺利，你将看到安装的 Django 版本号，如：4.2.7
## 2、安装mysqlclient
配置完之后，发现django开始报错了，是因为我们没有安装mysql的库，按照提示，安装mysqlclient就可以了。

```
pip install mysqlclient
```
## 3、安装pymysql 
如果您想使用pymysql代替mysqlclient来连接MySQL数据库，您需要遵循以下步骤：
安装pymysql
在终端中使用以下命令安装pymysql：

```
pip install pymysql
```
在Django项目中配置数据库
在Django项目中的settings.py文件中，将以下代码添加到文件末尾（请注意将“myproject”替换为项目名称）：

```
DATABASES = {
 'default': {
 'ENGINE': 'django.db.backends.mysql',
 'NAME': 'mydatabase',
 'USER': 'mydatabaseuser',
 'PASSWORD': 'mypassword',
 'HOST': 'localhost',
 'PORT': '3306',
 'OPTIONS': {
 'init_command': "SET sql_mode='STRICT_TRANS_TABLES'",
 'charset': 'utf8mb4',
 },
 'MYSQL': {
 'driver': 'pymysql',
 'charset': 'utf8mb4',
 },
 }
}
```
在上面的代码中，您需要更改以下选项：

NAME：数据库名称

USER：数据库用户名

PASSWORD：数据库密码

HOST：数据库主机地址

PORT：数据库端口号

## 更改数据库引擎设置
在Django项目中的__init__.py文件中，添加以下代码：

```
import pymysql
pymysql.install_as_MySQLdb()
```
这将设置pymysql作为MySQL

## django的基本操作

### 1.django创建一个项目

创建项目的命令，projects为项目名称
```
django-admin startproject projects 
```
### 2.django创建一个app

下面的命令在项目根目录中输入就可以新建app了
```
python manage.py startapp pm 
```
### 3.django启动项目
#### 3.1 第一种是命令启动
注意该命令在项目根目录下使用
```
python manage.py runserver 
```
#### 3.2 第二种是用pycharm启动

:::tip{title="提示"}
tip: 直接点击右上角的按钮即可
:::
### 4.django创建超级用户

```
python manage.py createsuperuser
```

Django安装和数据库配置及运行

制作一个Python的pip包涉及几个步骤，包括准备你的代码、编写必要的配置文件以及上传到PyPI（Python Package Index）。



### 1. **准备代码**：
 - 创建一个新的文件夹用于存放你的项目，里面至少应包含一个Python模块或包。
 - 如果你正在创建一个包，确保有一个`__init__.py`文件在你的包目录中。

### 2. **编写`setup.py`**：
 - 在项目的根目录下创建一个名为`setup.py`的文件。这个文件包含了关于你的包的信息和如何构建它。
 - 示例`setup.py`内容如下：
 ```python
 from setuptools import setup, find_packages

 setup(
 name='你的包名',
 version='0.1',
 packages=find_packages(),
 install_requires=[
 # 列出你的包依赖的其他包
 ],
 entry_points={
 'console_scripts': [
 # 如果你有命令行脚本的话，可以在这里定义
 ],
 },
 # 其他元数据如作者、描述等
 author="你的名字",
 author_email="你的邮箱",
 description="对你的包的一句话描述",
 long_description=open('README.md').read(),
 long_description_content_type='text/markdown',
 url="你的项目主页或仓库地址",
 )
 ```

### 3. **添加README和其他文档**：
 - 创建一个`README.md`文件来描述你的包，如何安装和使用等信息。

### 4. **构建你的包**：
 - 使用以下命令来生成分发包（这会在你的项目根目录下创建一个`dist/`文件夹）：
 ```
 python setup.py sdist bdist_wheel
 ```

### 5. **上传到PyPI**：
 `twine`是一个用于发布Python包到PyPI（Python Package Index）及其镜像的工具，它简化了上传过程，并提供了更安全的传输方式。下面是关于如何使用`twine`的详细说明：

#### 安装Twine

首先，你需要安装`twine`。可以通过pip来安装：

```bash
pip install twine
```

#### 准备你的项目

在使用`twine`之前，你需要确保你的项目已经准备好打包。这通常包括编写一个`setup.py`文件，以及其他必要的文档和配置文件。完成后，你可以通过以下命令生成分发文件：

```bash
python setup.py sdist bdist_wheel
```

这会在你的项目目录下创建一个`dist/`文件夹，里面包含了`.tar.gz`源分发和`.whl`轮子分发。

#### 配置PyPI账号

为了上传包，你需要一个PyPI账号。如果你还没有账号，可以在[PyPI](https://pypi.org/)上注册一个。

此外，推荐你设置一个`.pypirc`文件以避免每次上传时都需要输入用户名和密码。这个文件通常位于你的主目录下，并且内容如下：

```ini
[distutils]
index-servers =
 pypi
 pypitest

[pypi]
repository: https://upload.pypi.org/legacy/
username: your_username
password: your_password

[pypitest]
repository: https://test.pypi.org/legacy/
username: your_username
password: your_password
```

注意：出于安全考虑，最好使用环境变量或密码管理器来存储你的密码，而不是直接写在`.pypirc`文件中。

#### 上传包

有了分发文件和PyPI账号后，你可以使用`twine`上传这些文件：

```bash
twine upload dist/*
```

如果你想先测试上传过程，可以将包上传到[Test PyPI](https://test.pypi.org/)，这是一个专门用于测试的PyPI副本：

```bash
twine upload --repository-url https://test.pypi.org/legacy/ dist/*
```

### 6.验证上传

上传完成后，你可以尝试安装你的包来验证是否成功：

```bash
pip install your-package-name
```

对于Test PyPI，你需要指定额外的参数：

```bash
pip install --index-url https://test.pypi.org/simple/ your-package-name
```