Django学习篇01

简介

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

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

  1. MV(Model-View)模式:模型(Model)与数据库交互并处理业务逻辑,视图负责处理用户请求并渲染模板响应给用户。

  2. ORM(Object Relational Mapping):Django的ORM允许开发人员使用面向对象的方式与数据库进行交互,而无需直接使用SQL语句。通过定义模型类,开发人员可以轻松地创建、查询、更新和删除数据库记录。

  3. 路由系统:Django的路由系统能够将URL映射到相应的视图函数,这样当用户通过浏览器发送请求时,Django就能够找到合适的视图函数来处理请求。

  4. 模板引擎:Django提供强大的模板引擎,开发人员可以使用模板语法动态生成HTML页面,将数据传递给模板并渲染最终的输出,从而实现灵活的网页设计和内容呈现。

  5. 表单处理:Django提供了方便的表单处理机制,开发人员可以使用表单类来生成HTML表单、验证用户输入数据并处理表单提交。

  6. 自动化管理界面:Django自动生成管理界面,开发人员只需简单配置即可获得一个功能强大的后台管理界面,用于管理数据库记录和执行常见的管理任务。

  7. 安全性:Django内置了许多安全机制,包括防止常见的Web安全漏洞(如跨站点脚本(XSS)和跨站请求伪造(CSRF)),密码加密存储等,使得构建安全的Web应用程序变得更加容易。

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

安装与配置

  1. 安装Django:在激活的虚拟环境中,使用以下命令来安装Django:

    使用国内安装源:https://pypi.douban.com/simple
    使用命令行安装:pip install -i https://pypi.douban.com/simple django==3.2.13
  2. 创建Django项目:在命令行中,进入您想要创建项目的目录,并运行以下命令以创建Django项目:

    django-admin startproject myproject

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

    django-admin startproject 项目名称
    会在terminal所在目录下,创建一个新的独立的django项目工程
    
    django-admin startproject 项目名称 .
    会把terminal所在目录作为django项目的根目录,在此目录下创建项目
    项目名称:建议设置为Python中合法的标识符名称
    .代表在当前目录下创建
  3. 启动开发服务器:进入刚刚创建的项目目录,运行以下命令以启动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/)。

  4. 虚拟环境

    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项目中,存在以下主要文件和文件夹:

  1. 项目根目录:

    • manage.py:与Django项目进行交互的命令行工具。

    • mysite/:与项目根目录同名的文件夹,通常包含与项目相关的包和模块。

  2. 项目配置文件:

    • mysite/settings.py:定义了整个Django项目的全局配置设置,如数据库连接、应用程序列表、静态文件路径等。

    • mysite/urls.py:声明了整个Django项目的URL路由表,将特定URL映射到相应的视图函数。

  3. WSGI(Web Server Gateway Interface)相关文件:

    • mysite/wsgi.py:兼容WSGI协议的Web服务器入口文件,用于将请求传递给Django应用程序。

  4. 应用程序(Apps):

    • 可以在项目中创建多个应用程序,每个应用程序都是Django项目的一个可独立使用的、可重用的模块。

    • 每个应用程序通常包含以下文件和文件夹:

      • models.py:定义应用程序的数据模型(Model)。

      • views.py:定义应用程序的视图函数(View),处理用户请求并生成响应。

      • urls.py:定义应用程序的URL配置,将URL映射到相应的视图函数。

      • templates/:存放应用程序的HTML模板文件。

      • static/:存放应用程序的静态文件,如CSS、JavaScript和图像等。

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

修改默认时区

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

  1. 打开项目的设置文件 settings.py

  2. 寻找名为 TIME_ZONE 的设置项。默认情况下,它应该位于文件的顶部或附近。

  3. 更改 TIME_ZONE 的值为您所需的时区。您可以使用标准的时区名称,如 "Asia/Shanghai" 或 "America/New_York",也可以使用 UTC 偏移量,如 "+08:00"。

  4. 保存文件并关闭。

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

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

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

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

子应用

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

作用

  1. 模块化组织:子应用帮助将一个大型项目划分为小的、独立的功能模块。每个子应用可以专注于实现特定的功能,使代码更加模块化和可复用。这样的架构使得项目更易于理解、开发和维护。

  2. 代码复用:通过将功能划分为子应用,可以通过在不同的项目中重复使用它们来节省开发时间和工作量。一个子应用可以被多个项目引用,而无需重新实现相同的功能。

  3. 清晰的URL结构:通过子应用,可以根据不同模块的功能,将URL路径划分为不同的命名空间。这种结构可以帮助维护良好的URL设计,使得URL更加直观和易于理解。

  4. 管理后台扩展:Django的管理后台(admin)是一个强大的功能,通过创建子应用,可以将特定模型的管理操作集中在一个子应用中,使得管理后台更加清晰和易于管理。

  5. 充分利用Django的功能:子应用可以充分利用Django框架提供的各种功能,如模型、视图、表单、模板等。每个子应用可以独立地定义和使用这些功能,相互之间不会产生冲突。

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

基本步骤

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

  1. 在项目目录下,使用命令行终端进入项目所在的根目录。

  2. 运行以下命令创建一个新的子应用:

    python manage.py startapp myapp

    其中,myapp 是您给子应用起的名称。

  3. 创建子应用后,您会在项目目录中看到一个名为 myapp 的文件夹。该文件夹包含了子应用的代码、配置和其他相关文件。

  4. 在项目的 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',
    ]
    
  5. 在子应用的文件夹中,您可以定义模型、视图、URL路由、模板等功能。根据需要,可以在子应用中创建多个文件来组织您的代码。

  6. 配置子应用的URL路由:

    • 在子应用的文件夹中创建一个名为 urls.py 的文件(如果不存在)。

    • urls.py 文件中定义该子应用的URL路由规则,例如:

      from django.urls import path
      from . import views
      
      urlpatterns = [
          path('', views.index, name='index'),
          # 其他路径和视图配置
      ]

      这将为该子应用中的视图函数 my_view 创建一个URL路由。

  7. 在主应用的根 URL 配置文件(通常是项目的 urls.py 文件)中导入 include 函数,并为每个子应用定义一个路径。

    from django.urls import include, path
    
    urlpatterns = [
        # 其他路径和视图配置
        path('子应用路径/', include('子应用名称.urls')),
    ]

    这会将子应用的 URL 配置引入到主应用中,并为子应用定义一个访问路径。

    通过创建和使用子应用,您可以将项目的不同功能模块化,并将其独立开来,以便更好地组织和管理代码。这可以帮助提高项目的可维护性和扩展性,并使不同的功能部分更易于开发和维护。

  8. 在子应用的视图模块(例如 views.py)中,编写处理该子应用路由的视图函数。

    from django.shortcuts import render
    
    def index(request):
        return render(request, 'appname/index.html')
    

子应用结构

在Django中,子应用(或称为应用)的结构可以按照以下方式进行组织:

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

    appname/          # 子应用根目录
        ├── migrations/    # 数据库迁移文件目录
        ├── static/        # 静态文件目录(CSS、JavaScript、图片等)
        ├── templates/     # 模板文件目录
        ├── __init__.py    # 应用初始化文件
        ├── admin.py       # 管理后台注册和配置文件
        ├── models.py      # 数据库模型文件
        ├── views.py       # 视图文件
        └── urls.py        # URL 路由配置文件
    
  2. migrations 目录:该子应用用于存储数据库迁移文件,这些文件描述了数据库模型变更的历史记录,以及如何将现有数据库模式迁移到新的模型定义。Django会自动识别并执行这些迁移文件。

  3. static 目录:用于存储静态文件,如CSS样式表、JavaScript脚本和图像等。这些文件可以被应用程序的模板和视图引用。

  4. templates 目录:存放应用程序的HTML模板文件。模板用于生成最终的网页内容,并可以通过视图进行渲染和呈现。

  5. init.py 文件:通常为空文件,用于将该目录视为Python包。

  6. admin.py 文件:用于在Django的管理后台中注册和配置与该应用相关的模型。

  7. models.py 文件:定义应用程序的数据库模型。这些模型描述了应用程序中要存储的数据结构,并提供了与数据库的交互方式。

  8. views.py 文件:包含应用程序的视图函数或类。视图处理用户请求,并根据需要生成响应。

  9. urls.py 文件:用于配置应用程序的URL路由。它定义了URL路径与相应的视图之间的映射关系。

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

路由

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

怎样定义路由?

  1. 使用调用path函数的形式定义

  2. path函数第一个参数为url路径

    url路径,去掉“ip、域名:端口号/”之后,剩余的部分

    url路径前往往无需添加“/”,在url路径最后需要添加“/”

  3. path函数第二个参数为待调用的函数名(视图函数名称)

如何寻址?

  1. 一定会从urls.py全局路由文件中开始匹配,urlpatterns列表从上到下进行匹配

  2. 如果匹配不成功,会继续往后匹配

  3. 如果匹配成功,会【自动】调用path函数第二个参数指定的视图函数

  4. 同时一旦匹配成功会结束匹配

  5. 如果全部匹配不成功,那么会抛出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模式。

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

  1. 常规正则表达式匹配:

    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路径中捕获特定的年份,并将其传递给相应的视图函数。

  2. 参数数量匹配:

    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中,视图可以按照不同的分类标准进行划分。以下是一些常见的视图分类:

  1. 函数视图(Function-based Views):函数视图是最常用的视图类型,在Django中使用Python函数来定义。函数视图接收一个HttpRequest对象作为参数,并返回一个HttpResponse对象。它们是处理URL请求的基本方式。

  2. 类视图(Class-based Views):类视图是使用基于类的方式定义的视图。Django提供了许多内置的类视图,如基本视图(View)、列表视图(ListView)、详情视图(DetailView)等。类视图提供了更强大且灵活的功能,可以通过继承和重写类方法来实现特定的行为。

  3. 通用视图(Generic Views):通用视图是Django提供的一系列预定义视图类,用于处理常见的数据操作模式,如列表显示、详情显示、创建、更新和删除。通用视图提供了一种简化和快速开发的方式,可以根据实际需求选择适合的通用视图来处理数据。

  4. 视图集(Viewsets):视图集是Django REST framework的概念,用于处理RESTful API的视图。视图集通过将相关的行为组织在一起,提供了对资源的不同操作,如列表获取、创建、更新和删除等。视图集能够更好地组织和管理API的行为。

  5. 基于函数的装饰器视图(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 中简单而直观的处理视图的方式。通过编写函数来处理请求和生成响应,可以轻松实现各种操作,并提供灵活性和易用性。视图函数适用于简单的场景,不需要额外的复杂功能。

类视图

  1. 必须得继承View父类或者View子类

  2. 不同的请求方法是以实例方法来实现的

  3. 实例方法名与请求方法的对应关系

    get -> GET、post -> POST 、put -> PUT、 delete -> DELETE、patch -> PATCH

  4. 每一个实例方法需要返回HttpResponse对象或者HttpResponse子类的对象

  5. 如果类视图中未定义相应的实例方法,会报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 函数。此外,可以为类视图指定一个可选的名称,以便于在模板中或其他地方引用。

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

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

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

常用的 HttpRequest 对象的方法

  1. request.GET: 返回一个包含通过 GET 方法提交的参数的字典。可以使用类似于字典的语法 request.GET['name']request.GET.get('name') 来获取特定参数的值。

  2. request.POST: 返回一个包含通过 POST 方法提交的参数的字典。语法与 request.GET 相同。

  3. request.method: 返回请求的 HTTP 方法,例如 GET、POST、PUT、DELETE 等。可以使用 request.method == 'GET'request.method == 'POST' 来检查请求的方法类型。

  4. request.path: 返回请求的路径部分,即 URL 中域名后面的部分。

  5. request.META: 返回一个包含请求的元数据的字典,例如请求头部信息、用户 IP 地址等。可以使用 request.META['HTTP_USER_AGENT'] 来获取客户端的 User-Agent 信息。所有的参数名称被修改为:HTTP_请求头参数名全大写(如果有“-”,会转化为“_”)

  6. request.headers: 返回一个包含请求头部信息的字典。可以使用 request.headers['name'] 获取特定头部的值。

  7. request.FILES: 如果请求中包含了文件上传,该属性将包含上传的文件数据。在处理文件上传时,需要确保表单的 enctype 属性设置为 multipart/form-data

  8. request.is_ajax(): 判断请求是否为 AJAX 请求。如果是 AJAX 请求,将返回 True,否则返回 False

  9. request.COOKIES: 返回一个包含所有 cookies 的字典。可以使用 request.COOKIES['name'] 获取特定 cookie 的值。

  10. request.get_full_path(): 返回完整的请求路径,包括 URL 中的查询参数。

  11. request.methodHttpRequest 对象的一个属性,用于获取当前请求的 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 还提供了其他类型的响应对象,如 JsonResponseFileResponse 等。根据具体需求选择适合的响应类型。

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 还提供了其他类型的响应对象,如文件下载响应、流式响应等。根据具体的需求,选择适合的响应方式来返回给客户端。