Django学习篇01

简介

Django是一个用于构建Web应用程序的高级Python开发框架。它提供了一系列工具和功能，使开发人员能够快速、高效地构建复杂的Web应用程序。

下面是一些解释 Django 的重要概念和特性：

MV（Model-View）模式：模型（Model）与数据库交互并处理业务逻辑，视图负责处理用户请求并渲染模板响应给用户。
ORM（Object Relational Mapping）：Django的ORM允许开发人员使用面向对象的方式与数据库进行交互，而无需直接使用SQL语句。通过定义模型类，开发人员可以轻松地创建、查询、更新和删除数据库记录。
路由系统：Django的路由系统能够将URL映射到相应的视图函数，这样当用户通过浏览器发送请求时，Django就能够找到合适的视图函数来处理请求。
模板引擎：Django提供强大的模板引擎，开发人员可以使用模板语法动态生成HTML页面，将数据传递给模板并渲染最终的输出，从而实现灵活的网页设计和内容呈现。
表单处理：Django提供了方便的表单处理机制，开发人员可以使用表单类来生成HTML表单、验证用户输入数据并处理表单提交。
自动化管理界面：Django自动生成管理界面，开发人员只需简单配置即可获得一个功能强大的后台管理界面，用于管理数据库记录和执行常见的管理任务。
安全性：Django内置了许多安全机制，包括防止常见的Web安全漏洞（如跨站点脚本（XSS）和跨站请求伪造（CSRF）），密码加密存储等，使得构建安全的Web应用程序变得更加容易。

总结起来，Django是一个功能全面、易于使用且高度可定制的Python Web开发框架。它提供了许多工具和功能来帮助开发人员快速构建高质量的Web应用程序，并遵循最佳实践和安全标准。无论您要构建什么类型的Web应用程序，Django都是一个值得考虑的强大框架。

安装与配置

安装Django：在激活的虚拟环境中，使用以下命令来安装Django：

使用国内安装源：https://pypi.douban.com/simple
使用命令行安装：pip install -i https://pypi.douban.com/simple django==3.2.13

创建Django项目：在命令行中，进入您想要创建项目的目录，并运行以下命令以创建Django项目：

django-admin startproject myproject

这将在当前目录下创建一个名为myproject的Django项目文件夹。

django-admin startproject 项目名称
会在terminal所在目录下，创建一个新的独立的django项目工程

django-admin startproject 项目名称 .
会把terminal所在目录作为django项目的根目录，在此目录下创建项目
项目名称：建议设置为Python中合法的标识符名称
.代表在当前目录下创建

启动开发服务器：进入刚刚创建的项目目录，运行以下命令以启动Django开发服务器：

启动django项目
    方式一：
        a.打开terminal，进入到虚拟环境（自动）
        b.python manage.py runserver
            会默认在127.0.0.1上监听8000端口
        c.在其他端口监听
           python manage.py runserver 其他大于1024的端口号
        d.python manage.py runserver ip:port（ip:可以省略）
        e.使用ctrl + c退出项目

    方式二：
        a.在Pycharm专业版本上创建django的启动器
        b.点击右上角的“Add configuration” -> 点击“+”-> 选择“django” -> 设置启动的名称 -> 下方的“fix”
            -> Enable Django support -> 选django项目路径 -> settings.py所在路径

这将启动开发服务器，并监听默认的本地开发地址（http://127.0.0.1:8000/）。

虚拟环境

python -m venv myenv

其中，myenv是您指定的虚拟环境名称。

# 运行以下命令以激活虚拟环境：Windows
myenv\Scripts\activate

# macOS/Linux：
source myenv/bin/activate

项目结构

mysite/ 项目根目录
manage.py 以多种方式与Django项目交互的命令行工具
mysite/ 与项目根目录同名, 项目相关的包
mysite/settings.py 项目全局配置文件
mysite/urls.py 声明的全局url路由表
mysite/wsgi.py 兼容WSGI协议的web服务器入口文件

在一个典型的Django项目中，存在以下主要文件和文件夹：

项目根目录：
- manage.py：与Django项目进行交互的命令行工具。
- mysite/：与项目根目录同名的文件夹，通常包含与项目相关的包和模块。
项目配置文件：
- mysite/settings.py：定义了整个Django项目的全局配置设置，如数据库连接、应用程序列表、静态文件路径等。
- mysite/urls.py：声明了整个Django项目的URL路由表，将特定URL映射到相应的视图函数。
WSGI（Web Server Gateway Interface）相关文件：
- mysite/wsgi.py：兼容WSGI协议的Web服务器入口文件，用于将请求传递给Django应用程序。
应用程序（Apps）：
- 可以在项目中创建多个应用程序，每个应用程序都是Django项目的一个可独立使用的、可重用的模块。
- 每个应用程序通常包含以下文件和文件夹：
  - models.py：定义应用程序的数据模型（Model）。
  - views.py：定义应用程序的视图函数（View），处理用户请求并生成响应。
  - urls.py：定义应用程序的URL配置，将URL映射到相应的视图函数。
  - templates/：存放应用程序的HTML模板文件。
  - static/：存放应用程序的静态文件，如CSS、JavaScript和图像等。

这些是一个基本的Django项目结构。当您创建一个Django项目时，Django会根据该结构自动生成一些文件和文件夹，您可以根据项目的需求进行扩展和调整。这种结构可以帮助组织和管理项目的各个部分，使代码更具可读性和可维护性，并方便团队合作开发。

修改默认时区

要修改Django项目的默认时区，您可以按照以下步骤进行操作：

打开项目的设置文件 settings.py。
寻找名为 TIME_ZONE 的设置项。默认情况下，它应该位于文件的顶部或附近。
更改 TIME_ZONE 的值为您所需的时区。您可以使用标准的时区名称，如 "Asia/Shanghai" 或 "America/New_York"，也可以使用 UTC 偏移量，如 "+08:00"。
保存文件并关闭。

例如，要将默认时区设置为 "Asia/Shanghai"，您的 settings.py 中的设置项可能如下所示：

LANGUAGE_CODE = 'zh-hans'
TIME_ZONE = 'Asia/Shanghai'
USE_I18N = True
USE_L10N = True
USE_TZ = True

请确保选择适合您项目需求和地理位置的时区。

在Django中设置时区非常重要，因为它会影响到日期、时间和处理时区相关的功能。通过设置正确的时区，您可以确保项目在处理日期和时间时得到正确的结果，并与用户所在的地理位置保持一致。

子应用

在Django中，子应用（也称为子模块）是一种组织和划分项目功能的方式。子应用通常代表项目中具有独立功能的部分，可以将其视为项目的模块化组件。

作用

模块化组织：子应用帮助将一个大型项目划分为小的、独立的功能模块。每个子应用可以专注于实现特定的功能，使代码更加模块化和可复用。这样的架构使得项目更易于理解、开发和维护。
代码复用：通过将功能划分为子应用，可以通过在不同的项目中重复使用它们来节省开发时间和工作量。一个子应用可以被多个项目引用，而无需重新实现相同的功能。
清晰的URL结构：通过子应用，可以根据不同模块的功能，将URL路径划分为不同的命名空间。这种结构可以帮助维护良好的URL设计，使得URL更加直观和易于理解。
管理后台扩展：Django的管理后台（admin）是一个强大的功能，通过创建子应用，可以将特定模型的管理操作集中在一个子应用中，使得管理后台更加清晰和易于管理。
充分利用Django的功能：子应用可以充分利用Django框架提供的各种功能，如模型、视图、表单、模板等。每个子应用可以独立地定义和使用这些功能，相互之间不会产生冲突。

总而言之，子应用在Django中的作用是帮助组织、划分和管理项目的功能模块，实现代码的模块化、可维护性和复用性。通过使用子应用，可以更好地组织和扩展项目，并提高开发效率和代码质量。

基本步骤

以下是在Django中创建和使用子应用的基本步骤：

在项目目录下，使用命令行终端进入项目所在的根目录。
运行以下命令创建一个新的子应用：
```
python manage.py startapp myapp
```
其中，myapp 是您给子应用起的名称。
创建子应用后，您会在项目目录中看到一个名为 myapp 的文件夹。该文件夹包含了子应用的代码、配置和其他相关文件。

在项目的 settings.py 文件中，找到 INSTALLED_APPS 设置项，并将子应用添加到该列表中：

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    # 方式一：'子应用名'
    'projects',
    # '子应用名.apps.子应用名首字母大写Config'
    # 'projects.apps.ProjectsConfig',
    'users',
]

在子应用的文件夹中，您可以定义模型、视图、URL路由、模板等功能。根据需要，可以在子应用中创建多个文件来组织您的代码。
配置子应用的URL路由：
- 在子应用的文件夹中创建一个名为 urls.py 的文件（如果不存在）。
- 在 urls.py 文件中定义该子应用的URL路由规则，例如：
```
from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
    # 其他路径和视图配置
]
```
  这将为该子应用中的视图函数 my_view 创建一个URL路由。
在主应用的根 URL 配置文件（通常是项目的 urls.py 文件）中导入 include 函数，并为每个子应用定义一个路径。
```
from django.urls import include, path

urlpatterns = [
    # 其他路径和视图配置
    path('子应用路径/', include('子应用名称.urls')),
]
```
这会将子应用的 URL 配置引入到主应用中，并为子应用定义一个访问路径。
通过创建和使用子应用，您可以将项目的不同功能模块化，并将其独立开来，以便更好地组织和管理代码。这可以帮助提高项目的可维护性和扩展性，并使不同的功能部分更易于开发和维护。

在子应用的视图模块（例如 views.py）中，编写处理该子应用路由的视图函数。

from django.shortcuts import render

def index(request):
    return render(request, 'appname/index.html')

子应用结构

在Django中，子应用（或称为应用）的结构可以按照以下方式进行组织：

应用目录：每个子应用都可以拥有自己的目录，其中包含与该应用相关的文件。通常情况下，一个子应用的目录结构如下所示：

appname/          # 子应用根目录
    ├── migrations/    # 数据库迁移文件目录
    ├── static/        # 静态文件目录（CSS、JavaScript、图片等）
    ├── templates/     # 模板文件目录
    ├── __init__.py    # 应用初始化文件
    ├── admin.py       # 管理后台注册和配置文件
    ├── models.py      # 数据库模型文件
    ├── views.py       # 视图文件
    └── urls.py        # URL 路由配置文件

migrations 目录：该子应用用于存储数据库迁移文件，这些文件描述了数据库模型变更的历史记录，以及如何将现有数据库模式迁移到新的模型定义。Django会自动识别并执行这些迁移文件。
static 目录：用于存储静态文件，如CSS样式表、JavaScript脚本和图像等。这些文件可以被应用程序的模板和视图引用。
templates 目录：存放应用程序的HTML模板文件。模板用于生成最终的网页内容，并可以通过视图进行渲染和呈现。
init.py 文件：通常为空文件，用于将该目录视为Python包。
admin.py 文件：用于在Django的管理后台中注册和配置与该应用相关的模型。
models.py 文件：定义应用程序的数据库模型。这些模型描述了应用程序中要存储的数据结构，并提供了与数据库的交互方式。
views.py 文件：包含应用程序的视图函数或类。视图处理用户请求，并根据需要生成响应。
urls.py 文件：用于配置应用程序的URL路由。它定义了URL路径与相应的视图之间的映射关系。

这样的子应用结构可以使代码组织有条理，便于开发、维护和扩展。您可以根据具体项目需求和功能模块划分来安排子应用的结构。

路由

在Django中，路由（Routing）用于将URL请求映射到相应的视图函数或类。通过路由配置，可以定义URL路径与应用程序的处理逻辑之间的对应关系。

怎样定义路由？

使用调用path函数的形式定义
path函数第一个参数为url路径
url路径，去掉“ip、域名:端口号/”之后，剩余的部分
url路径前往往无需添加“/”，在url路径最后需要添加“/”
path函数第二个参数为待调用的函数名（视图函数名称）

如何寻址？

一定会从urls.py全局路由文件中开始匹配，urlpatterns列表从上到下进行匹配
如果匹配不成功，会继续往后匹配
如果匹配成功，会【自动】调用path函数第二个参数指定的视图函数
同时一旦匹配成功会结束匹配
如果全部匹配不成功，那么会抛出404异常（404页面）

在Django中，路由配置主要通过以下两个文件进行：

项目级别的urls.py

该文件位于项目的根目录下，用于定义整个项目的URL路由。它通常包含了项目中所有子应用的路由配置。

from django.contrib import admin
from django.urls import include, path

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('appname.urls')),
    # 其他子应用的路由配置
]

admin/：将 admin/ 路径映射到 Django 自带的管理后台应用。当您访问 http://yourdomain.com/admin/ 时，将显示 Django 的管理后台界面。
''：将根路径映射到应用。
include('appone.urls')：导入名为 appone 的子应用的 URL 配置。

子应用级别的urls.py

每个子应用都拥有自己的urls.py文件，用于定义该子应用的URL路由规则。

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),  # 空路径，映射到index视图函数
    path('about/', views.about, name='about'),  # /about/ 路径，映射到about视图函数
    # 其他路由规则
]

在上述示例中，项目级别的urls.py文件通过include()函数引入了子应用的urls.py文件，实现了子应用路由的配置。

在路由配置中，path()函数用于定义URL路径与视图的映射关系。第一个参数是URL路径字符串，第二个参数是要调用的视图函数或类，第三个参数是URL的名称（可选）。

路由还支持动态路由和正则表达式等高级用法，可以根据需要进行更复杂的路由配置。

总结起来，Django中的路由配置主要通过项目级别的urls.py文件和子应用级别的urls.py文件来定义。通过这些配置，可以将URL请求映射到相应的视图函数或类，实现了请求的分发和处理。

正则表达式进行路径匹配(补充)

在Django的路由配置中，可以使用正则表达式进行路径匹配。正则表达式允许我们更灵活地定义路由规则，可以匹配特定的URL模式。

下面是一些常用的正则表达式示例：

常规正则表达式匹配：
```
from django.urls import re_path

urlpatterns = [
    re_path(r'^articles/(?P<year>[0-9]{4})/$', views.article_year, name='article_year'),
]
```
在上面的例子中，URL路径将以/articles/开头，后跟四个数字（特定年份），以/结尾。通过使用命名分组（?P<year>），我们可以从URL路径中捕获特定的年份，并将其传递给相应的视图函数。
参数数量匹配：
```
from django.urls import re_path

urlpatterns = [
    re_path(r'^blog/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$', views.blog_archive, name='blog_archive'),
]
```
在这个例子中，URL路径的形式为/blog/年份/月份/。通过使用多个命名分组，我们可以从URL路径中捕获不同的参数值，并将其传递给相应的视图函数。

^是一个元字符，表示匹配字符串的开头。
$是一个元字符，表示匹配字符串的结尾。
?P是在Django路由中使用的正则表达式语法，用于为匹配的子字符串创建一个命名捕获组。
在正则表达式中，?P<name>的语法表示创建一个命名捕获组，其中name是该组的名称。通过这个命名捕获组，可以从URL路径中提取特定的值，并将其传递给视图函数或类。
[0-9]表示匹配任意一个数字字符，等同于\d。
{4}表示前面的模式（即数字）必须连续出现四次。

`reverse` 函数

reverse 是 Django 框架中的一个函数，用于根据路由的名称（name）反向解析出对应的 URL。

在 Django 中，为每个路由都可以设置一个独特的名称。这样，当我们在视图函数、模板或其他地方需要生成该路由对应的 URL 时，就可以使用 reverse 函数来自动生成 URL，而不需要硬编码 URL。

reverse 函数的语法如下：

reverse(viewname, args=None, kwargs=None, current_app=None)

viewname：需要反向解析的路由的名称（name），它是一个字符串。例如，'projects:index'。
args：一个包含位置参数的元组。如果路由的路径中有位置参数，可以通过 args 参数传递。默认值为 None。
kwargs：一个包含关键字参数的字典。如果路由的路径中有关键字参数，可以通过 kwargs 参数传递。默认值为 None。
current_app：用于处理命名空间的应用程序实例的名称。默认值为 None。

reverse 函数将返回一个字符串，即根据给定的 viewname、args 和 kwargs 解析出的 URL。

使用 reverse 函数的好处是，当我们修改了路由的 URL 路径时，无需手动修改所有硬编码的 URL，而只需要修改路由配置中的 URL 和对应的名称，然后 Django 就会自动更新应用程序中使用 reverse 函数生成的 URL。

需要注意的是，要使用 reverse 函数，必须将每个路由都设置一个唯一的名称。在 Django 的路由配置中，我们可以通过 name 参数为每个路由设置名称。例如：

path('projects/', views.project_list, name='projects:index')

然后，我们就可以在视图函数或模板中使用 reverse 函数来生成该路由对应的 URL，而不需要直接指定 URL 路径。

总结起来，reverse 函数是 Django 框架中用于反向解析出路由对应的 URL 的便捷方法，可以避免硬编码 URL，提高代码的可维护性。

如：

projects\views.py

def index(request):
    # reverse函数的作用：根据路由的name反向解析出路由对应的url
    url1 = reverse('projects:index')
    url2 = reverse('projects:detail', args=(888, ))
    return HttpResponse(f"这个是前端需要的项目列表数据，url1: {url1}, url2: {url2}")

projects\urls.py

from django.urls import path, re_path

from . import views
# 定义app_name的值，用于给路由添加命名空间
# 作用：当项目中有多个应用时，可以通过命名空间来区分不同应用中的路由
# 例如：当项目中有两个应用，分别为projects和interfaces，且两个应用中都有get_project视图函数
app_name = 'projects'

urlpatterns = [
    path('', views.index, name='index'),
    path('<int:pid>/', views.detail, name='detail'),
]

视图

在Django中，视图可以按照不同的分类标准进行划分。以下是一些常见的视图分类：

函数视图（Function-based Views）：函数视图是最常用的视图类型，在Django中使用Python函数来定义。函数视图接收一个HttpRequest对象作为参数，并返回一个HttpResponse对象。它们是处理URL请求的基本方式。
类视图（Class-based Views）：类视图是使用基于类的方式定义的视图。Django提供了许多内置的类视图，如基本视图（View）、列表视图（ListView）、详情视图（DetailView）等。类视图提供了更强大且灵活的功能，可以通过继承和重写类方法来实现特定的行为。
通用视图（Generic Views）：通用视图是Django提供的一系列预定义视图类，用于处理常见的数据操作模式，如列表显示、详情显示、创建、更新和删除。通用视图提供了一种简化和快速开发的方式，可以根据实际需求选择适合的通用视图来处理数据。
视图集（Viewsets）：视图集是Django REST framework的概念，用于处理RESTful API的视图。视图集通过将相关的行为组织在一起，提供了对资源的不同操作，如列表获取、创建、更新和删除等。视图集能够更好地组织和管理API的行为。
基于函数的装饰器视图（Decorator-based Views）：Django还支持使用装饰器来定义视图。装饰器可以用于添加额外的功能或验证，例如登录验证、权限检查等。可以将装饰器应用于函数视图或类视图。

这些是常见的视图分类，它们根据不同的特征或用途划分。选择适当的视图类型取决于您的项目需求和开发风格。一般而言，函数视图和类视图是最常用的两种视图类型。

函数视图

在 Django 中，视图函数（View Functions）是一种定义和处理视图的方式。通过编写函数来处理请求并生成响应，可以简单而直观地处理各种操作。

视图函数的定义非常简单，只需创建一个函数，并将 request 对象作为参数，然后返回一个包含响应内容的 HttpResponse 对象。以下是一个简单的视图函数示例：

from django.http import HttpResponse

def my_view(request):
    # 处理请求的逻辑
    return HttpResponse("This is my view.")

在上面的示例中，我们定义了一个名为 my_view 的视图函数。在函数中，我们可以根据请求对象 request 的属性和方法来处理请求的数据或执行相应的操作。最后，通过返回一个 HttpResponse 对象，我们可以将响应内容发送回客户端。

使用视图函数非常简单，只需将函数关联到 URL 路由即可。以下是一个将 my_view 视图函数关联到 URL 的示例：

from django.urls import path
from .views import my_view

urlpatterns = [
    path('myview/', my_view, name='my-view'),
]

通过将视图函数作为第二个参数传递给 path 函数，我们将它与特定的 URL 路径（例如 myview/）进行关联。此外，可以为视图函数指定一个可选的名称，以便于在模板中或其他地方引用。

视图函数可以根据需要接受其他参数，如 URL 参数、查询字符串、表单数据等。可以通过函数参数来接收这些数据，并在处理逻辑中使用。

def detail(request, pid):
    """
    函数视图的参数和返回
    a.第一个参数为HttpRequest对象或HttpRequest子类
    b.当路由匹配成功后，django框架会将前端的请求所有数据封装为HttpRequest，在调用视图函数时自动传递给函数的第一个参数
    c.可以使用HttpRequest对象中的method属性获取请求方法名称（大写），可以通过不同的请求方法，执行不一样业务逻辑
    b.函数视图必须返回HttpResponse对象或者HttpResponse子类的对象
    :param request:
    :param pid:
    :return:
    """
    # return HttpResponse(f"这是前端需要的项目详情数据: {pid}")

    if request.method == 'GET':
        return HttpResponse(content='<h1>获取id为{pid}的项目详情数据</h1>', status=200)

    elif request.method == 'POST':
        return HttpResponse(f'<h1>创建项目数据</h1>', status=201)

    elif request.method == 'PUT':
        # 返回json格式的数据
        data_dict = {
            "name": "lemon项目",
            "id": pid
        }
        # data_str = json.dumps(data_dict, ensure_ascii=False, indent=2)
        # return HttpResponse(data_str, status=201, content_type='application/json')
        return JsonResponse(data_dict, json_dumps_params={
            'ensure_ascii': False,
            'indent': 2
        })

    elif request.method == "DELETE":
        return HttpResponse(f'<h1>删除id为{pid}的项目数据</h1>', status=204)

    else:
        return HttpResponse(f"这是前端需要的项目详情数据: {pid}", status=201, content_type='text/html', charset='utf8', headers={
            'XXX': 'xxx'
        })

总结来说，视图函数是 Django 中简单而直观的处理视图的方式。通过编写函数来处理请求和生成响应，可以轻松实现各种操作，并提供灵活性和易用性。视图函数适用于简单的场景，不需要额外的复杂功能。

类视图

必须得继承View父类或者View子类
不同的请求方法是以实例方法来实现的
实例方法名与请求方法的对应关系
get -> GET、post -> POST 、put -> PUT、 delete -> DELETE、patch -> PATCH
每一个实例方法需要返回HttpResponse对象或者HttpResponse子类的对象
如果类视图中未定义相应的实例方法，会报405异常

类视图（Class-based Views）是 Django 中一种基于类的方式来定义视图。与函数视图相比，类视图提供了更强大和灵活的功能，并可以通过继承和重写类方法来实现特定的行为。

类视图的定义非常简单，只需创建一个继承自 Django 提供的基类的类，并重写其中的方法。以下是一个简单的类视图示例：

from django.views import View
from django.http import HttpResponse

class MyView(View):
    def get(self, request):
        # 处理 GET 请求的逻辑
        return HttpResponse("This is a GET request.")

    def post(self, request):
        # 处理 POST 请求的逻辑
        return HttpResponse("This is a POST request.")

在上面的示例中，我们定义了一个名为 MyView 的类视图，它继承自 View 类。通过重写 get 方法和 post 方法，我们可以分别处理 GET 请求和 POST 请求，并返回相应的响应。

使用类视图非常简单，只需将类视图关联到 URL 路由即可。以下是一个将 MyView 类视图关联到 URL 的示例：

from django.urls import path
from .views import MyView

urlpatterns = [
    path('myview/', MyView.as_view(), name='my-view'),
]

通过 as_view() 方法将类视图转换为可调用的视图对象，并将其作为第二个参数传递给 path 函数。此外，可以为类视图指定一个可选的名称，以便于在模板中或其他地方引用。

类视图还提供了其他一些常用的方法，例如 put、delete 等，可以根据需要重写这些方法来处理相应的 HTTP 方法。

除了基本的类视图外，Django 还提供了许多内置的通用视图类，如 ListView、DetailView、CreateView、UpdateView、DeleteView 等。这些通用视图类提供了处理常见数据操作模式的功能，并且可以通过简单的配置来完成大部分工作。

总结来说，类视图是 Django 中更灵活和可扩展的方式来定义视图。通过继承和重写类方法，可以实现特定的行为，并更好地组织和管理视图逻辑。

常用的 `HttpRequest` 对象的方法

request.GET: 返回一个包含通过 GET 方法提交的参数的字典。可以使用类似于字典的语法 request.GET['name'] 或 request.GET.get('name') 来获取特定参数的值。
request.POST: 返回一个包含通过 POST 方法提交的参数的字典。语法与 request.GET 相同。
request.method: 返回请求的 HTTP 方法，例如 GET、POST、PUT、DELETE 等。可以使用 request.method == 'GET' 或 request.method == 'POST' 来检查请求的方法类型。
request.path: 返回请求的路径部分，即 URL 中域名后面的部分。
request.META: 返回一个包含请求的元数据的字典，例如请求头部信息、用户 IP 地址等。可以使用 request.META['HTTP_USER_AGENT'] 来获取客户端的 User-Agent 信息。所有的参数名称被修改为：HTTP_请求头参数名全大写（如果有“-”，会转化为“_”）
request.headers: 返回一个包含请求头部信息的字典。可以使用 request.headers['name'] 获取特定头部的值。
request.FILES: 如果请求中包含了文件上传，该属性将包含上传的文件数据。在处理文件上传时，需要确保表单的 enctype 属性设置为 multipart/form-data。
request.is_ajax(): 判断请求是否为 AJAX 请求。如果是 AJAX 请求，将返回 True，否则返回 False。
request.COOKIES: 返回一个包含所有 cookies 的字典。可以使用 request.COOKIES['name'] 获取特定 cookie 的值。
request.get_full_path(): 返回完整的请求路径，包括 URL 中的查询参数。
request.method 是 HttpRequest 对象的一个属性，用于获取当前请求的 HTTP 方法。

这些方法只是 HttpRequest 对象的一部分功能，还有其他方法可以用于 HTTP 请求的处理和访问请求数据。根据具体的需求，可以选择适当的方法来操作 HttpRequest 对象。

请求与响应

请求参数类型

查询参数（Query Parameters）

使用request.GET属性获取
request.GET返回QueryDict对象，是一个like-dict类字典类型，与字典类似（但有区别）
使用request.GET['key']或者request.GET.get('key')，如果多个参数中有名称相同的参数，获取的是最后一个值
使用request.GET.getlist('key')去获取有名称相同的参数所有值，返回列表类型

假设我们有一个URL https://example.com/api/?name=John&age=25，其中包含了查询参数name和age。可以使用以下代码来获取和处理查询参数：

name = request.GET.get('name')  # 获取name参数的值
age = request.GET.get('age')  # 获取age参数的值

请求体参数

表单数据（Form Data或者application/x-www-form-urlencoded）

使用request.POST获取
request.POST返回QueryDict对象，是一个like-dict类字典类型，与字典类似（但有区别）
使用request.POST['key']或者request.POST.get('key')，如果多个参数中有名称相同的参数，获取的是最后一个值
使用request.POST.getlist('key')去获取有名称相同的参数所有值，返回列表类型

假设我们有一个POST请求，其中包含了表单数据。可以使用以下代码来获取和处理表单数据：

name = request.POST.get('name')  # 获取表单字段name的值
email = request.POST.get('email')  # 获取表单字段email的值

JSON数据

假设我们有一个POST请求，其中包含了JSON数据。可以使用以下代码来获取和处理JSON数据：

import json

data = json.loads(request.body)  # 解析JSON数据
name = data['name']  # 获取name字段的值
age = data['age']  # 获取age字段的值

文件上传

假设我们有一个包含文件上传字段的表单。可以使用以下代码来获取上传的文件：

创建的文件参数可以使用request.FILES获取，为MultiValueDict（是一个like-dict类型）

file = request.FILES['myfile']  # 获取上传的文件对象
# 可以对文件进行处理，如保存到磁盘或进行其他操作
# 如：
        file_data = None
        if request.content_type == 'multipart/form-data':
            file_data = request.FILES.get('file')
            with open('./xxx.png', 'wb+') as obj:
                for st in file_data.chunks():
                    obj.write(st)

URL参数（URL Parameters）

假设我们有一个URL模式定义如下：path('user/<int:user_id>/', views.user_detail)，其中user_id是URL参数。可以通过以下方式获取URL参数值：在函数视图或者类视图的实例方法中使用关键字作为参数名去接收

def user_detail(request, user_id):
    # 使用user_id进行处理
    ...

在这个例子中，当URL匹配到user/123/时，Django会将123作为参数传递给user_detail函数的user_id参数。你可以在函数中使用user_id进行后续的处理和操作。

URL参数可以根据需要进行定义，并可以是不同类型的数据（如整数、字符串等）。在URL模式中，使用<type:parameter>的形式来指定参数类型，其中type表示参数的类型，如int表示整数类型，str表示字符串类型等。

除了使用<type:parameter>来定义URL参数，还可以使用其他特殊的转换器，如slug用于处理带有连字符的字符串，uuid用于处理UUID字符串等。你可以根据具体的需求选择合适的转换器。

获取请求头参数

user_agent = request.META.get('HTTP_USER_AGENT')
custom_header = request.META.get('HTTP_ONE_VAR')

响应

在 Django 中，可以使用各种方式来进行响应的处理。以下是几种常见的 Django 响应方式：

字符串响应：

使用 django.http.HttpResponse 类可以返回一个简单的字符串响应。例如：

from django.http import HttpResponse

def my_view(request):
    return HttpResponse("Hello, World!")

HttpResponse 还可以接收其他一些参数来定制响应。以下是一些常用的参数：

content：作为响应体返回的内容，通常是一个字符串。默认为空字符串。
content_type：指定响应体的数据类型。默认为 "text/html"。
status：指定响应的 HTTP 状态码。默认为 200。
reason：指定与状态码对应的原因短语。默认根据状态码自动确定原因短语。
charset：指定响应体的字符编码。默认为 "utf-8"。
headers：一个字典，包含要添加到响应头的任意额外标头。例如，可以使用 headers={'X-Custom-Header': 'Value'} 添加自定义标头。

以下是使用 HttpResponse 的示例，展示了如何使用这些参数：

from django.http import HttpResponse

def my_view(request):
    content = "Hello, World!"
    headers = {'X-Custom-Header': 'Value'}
    return HttpResponse(content, content_type="text/plain", status=200, reason="Custom Reason", charset="utf-8", headers=headers)

在上述示例中，我们通过适当设置参数，定制了响应的内容类型、状态码、原因短语、字符编码以及添加了一个自定义标头。

请注意，大多数情况下，使用简单的 HttpResponse 足够满足需求。如果需要更复杂的响应处理，Django 还提供了其他类型的响应对象，如 JsonResponse、FileResponse 等。根据具体需求选择适合的响应类型。

JSON 响应：

使用 django.http.JsonResponse 类可以返回一个 JSON 格式的响应。例如：

from django.http import JsonResponse

def my_view(request):
    data = {'message': 'Hello, World!'}
    return JsonResponse(data)

模板响应：

使用 Django 的模板引擎可以渲染并返回一个 HTML 页面作为响应。例如：

from django.shortcuts import render

def my_view(request):
    context = {'message': 'Hello, World!'}
    return render(request, 'my_template.html', context)

重定向响应：

使用 django.shortcuts.redirect 函数可以进行页面重定向。例如：

from django.shortcuts import redirect

def my_view(request):
    return redirect('/new_url/')

以上只是一些常见的响应方式，Django 还提供了其他类型的响应对象，如文件下载响应、流式响应等。根据具体的需求，选择适合的响应方式来返回给客户端。

Django学习篇01-基础

Django学习篇01

简介

安装与配置

项目结构

修改默认时区

子应用

作用

基本步骤

子应用结构

路由

怎样定义路由？

如何寻址？

项目级别的urls.py

子应用级别的urls.py

正则表达式进行路径匹配(补充)

`reverse` 函数

视图

函数视图

类视图

常用的 `HttpRequest` 对象的方法

请求与响应

请求参数类型

查询参数（Query Parameters）

请求体参数

表单数据（Form Data或者application/x-www-form-urlencoded）

JSON数据

文件上传

URL参数（URL Parameters）

获取请求头参数

响应

字符串响应：

JSON 响应：

模板响应：

重定向响应：

评论

Django学习篇01-基础

Django学习篇01

简介

安装与配置

项目结构

修改默认时区

子应用

作用

基本步骤

子应用结构

路由

怎样定义路由？

如何寻址？

项目级别的urls.py

子应用级别的urls.py

正则表达式进行路径匹配(补充)

reverse 函数

视图

函数视图

类视图

常用的 HttpRequest 对象的方法

请求与响应

请求参数类型

查询参数（Query Parameters）

请求体参数

表单数据（Form Data或者application/x-www-form-urlencoded）

JSON数据

文件上传

URL参数（URL Parameters）

获取请求头参数

响应

字符串响应：

JSON 响应：

模板响应：

重定向响应：

评论

`reverse` 函数

常用的 `HttpRequest` 对象的方法