本文档介绍了 Django 验证系统在默认配置下的使用方法。默认配置满足最常见的项目需求，可以处理相当多的任务，还有一个安全的密码和权限实现。对于验证需求与默认配置不同的项目，Django 支持对身份验证进行扩展和定制。
\nDjango 验证同时提供身份验证和授权，通常称为身份验证系统，因为这些功能在某种程度上是耦合的。
\nUser 对象Link to this heading#User 对象是认证系统的核心。它们通常代表与你网站进行交互的人，并用于启用诸如限制访问、注册用户配置文件、将内容与创建者关联等功能。在 Django 的认证框架中只存在一个用户类，即 'superusers' 或管理员 'staff' 用户只是具有特殊属性设置的用户对象，而不是不同类别的用户对象。
默认用户的主要属性是：
\n请查看 完整的 API 文档 以获取详细的参考信息，接下来的文档更偏向于任务导向。
创建用户的最直接方法是使用包含的 create_user() 辅助函数：
>>> from django.contrib.auth.models import User\n>>> user = User.objects.create_user("john", "lennon@thebeatles.com", "johnpassword")\n\n# At this point, user is a User object that has already been saved\n# to the database. You can continue to change its attributes\n# if you want to change other fields.\n>>> user.last_name = "Lennon"\n>>> user.save()\n如果你安装了 Django 管理界面，你还可以 以交互方式创建用户。
\n使用 createsuperuser 命令创建超级用户：
Linux / macOS
$ python manage.py createsuperuser --username=joe --email=joe@example.com\nWindows
...\\> py manage.py createsuperuser --username=joe --email=joe@example.com\n你将被要求输入密码。输入密码后，用户将立即创建。如果你不使用 --username 或 --email 选项，它将提示你输入这些值。
Django 不会在用户模型上存储原始（明文）密码，而只会存储散列值（详细信息请参阅 有关密码管理的文档）。因此，请不要尝试直接操作用户的密码属性。这就是在创建用户时使用辅助函数的原因。
\n更改一个用户的密码，你有几个选择：
\nmanage.py changepassword *username* 提供了一种从命令行更改用户密码的方法。它会提示您更改指定用户的密码，你必须输入两次密码。如果它们都匹配，新密码将立即更改。如果你不提供用户名，该命令将尝试更改与当前系统用户匹配的用户名的密码。
You can also change a password programmatically, using\nset_password():
>>> from django.contrib.auth.models import User\n>>> u = User.objects.get(username="john")\n>>> u.set_password("new password")\n>>> u.save()\n如果你已安装了 Django 管理员界面，你也可以在 身份验证系统的管理员页面 上更改用户的密码。
\nDjango 还提供了可以用于允许用户更改自己密码的 视图 和 表单。
\n更改用户的密码将注销其所有会话。请参阅 password-change-session-invalidation 以获取详细信息。
\n异步版本：aauthenticate()
Use authenticate() to verify a set of\ncredentials. It takes credentials as keyword arguments, username and\npassword for the default case, checks them against each\nauthentication backend, and returns a\nUser object if the credentials are\nvalid for a backend. If the credentials aren't valid for any backend or if\na backend raises PermissionDenied, it\nreturns None. For example:
from django.contrib.auth import authenticate\n\nuser = authenticate(username="john", password="secret")\nif user is not None:\n # A backend authenticated the credentials\n ...\nelse:\n # No backend authenticated the credentials\n ...\nrequest 是一个可选的 HttpRequest，它被传递给身份验证后端的 authenticate() 方法。
Django 使用 会话 和中间件将身份验证系统与 请求对象 钩连在一起。
这些提供了每个请求上的 request.user 属性和 request.auser 异步方法，表示当前用户。如果当前用户未登录，这个属性将被设置为 AnonymousUser 的实例，否则它将是 User 的实例。
你可以使用 is_authenticated 来区分它们，如下所示：
if request.user.is_authenticated:\n # Do something for authenticated users.\n ...\nelse:\n # Do something for anonymous users.\n ...\n或者在一个异步视图中：
\nuser = await request.auser()\nif user.is_authenticated:\n # Do something for authenticated users.\n ...\nelse:\n # Do something for anonymous users.\n ...\n如果你有一个已经经过认证的用户，想要将其附加到当前会话中，可以使用 login() 函数来实现。
异步版本：alogin()
To log a user in, from a view, use login(). It\ntakes an HttpRequest object and a\nUser object.\nlogin() saves the user's ID in the session,\nusing Django's session framework.
请注意，在用户登录后，匿名会话期间设置的任何数据都将保留在会话中。
\nThis example shows how you might use both\nauthenticate() and\nlogin():
from django.contrib.auth import authenticate, login\n\n\ndef my_view(request):\n username = request.POST["username"]\n password = request.POST["password"]\n user = authenticate(request, username=username, password=password)\n if user is not None:\n login(request, user)\n # Redirect to a success page.\n ...\n else:\n # Return an 'invalid login' error message.\n ...\n当用户登录时，用户的 ID 和用于认证的后端被保存在用户的会话中。这允许相同的 认证后端 在将来的请求中获取用户的详细信息。要保存在会话中的认证后端是按以下方式选择的：
\n使用可选的 backend 参数的值，如果提供了的话。
Use the value of the user.backend attribute, if present. This allows\npairing authenticate() and\nlogin():\nauthenticate()\nsets the user.backend attribute on the user object it returns.
如果只有一个 AUTHENTICATION_BACKENDS 中的后端，则使用其中的后端。
否则，抛出一个异常。
在情况 1 和情况 2 中，backend 参数的值或 user.backend 属性应该是一个点分路径字符串（类似于 AUTHENTICATION_BACKENDS 中的路径），而不是实际的后端类。
异步版本：alogout()
To log out a user who has been logged in via\ndjango.contrib.auth.login(), use\ndjango.contrib.auth.logout() within your view. It takes an\nHttpRequest object and has no return value.\nExample:
from django.contrib.auth import logout\n\n\ndef logout_view(request):\n logout(request)\n # Redirect to a success page.\nNote that logout() doesn't throw any errors if\nthe user wasn't logged in.
When you call logout(), the session data for\nthe current request is completely cleaned out. All existing data is\nremoved. This is to prevent another person from using the same web browser\nto log in and have access to the previous user's session data. If you want\nto put anything into the session that will be available to the user\nimmediately after logging out, do that after calling\ndjango.contrib.auth.logout().
限制访问页面的原始方法是检查 request.user.is_authenticated 并且要么重定向到登录页面：
from django.conf import settings\nfrom django.shortcuts import redirect\n\n\ndef my_view(request):\n if not request.user.is_authenticated:\n return redirect(f"{settings.LOGIN_URL}?next={request.path}")\n # ...\n...或者显示一个错误消息：
\nfrom django.shortcuts import render\n\n\ndef my_view(request):\n if not request.user.is_authenticated:\n return render(request, "myapp/login_error.html")\n # ...\nlogin_required 装饰器Link to this heading#作为一种快捷方式，你可以使用方便的 login_required() 装饰器：
from django.contrib.auth.decorators import login_required\n\n\n@login_required\ndef my_view(request): ...\nlogin_required() 会执行以下操作：
如果用户没有登录，重定向到 settings.LOGIN_URL，在查询字符串中传递当前的绝对路径。例如： /accounts/login/?next=/polls/3/。
如果用户已登录，正常执行视图。视图代码可以自由地假设用户已登录。
默认情况下，用户成功认证后应重定向到的路径存储在名为 "next" 的查询字符串参数中。如果你想要使用不同的参数名称，login_required() 接受一个可选的 redirect_field_name 参数：
from django.contrib.auth.decorators import login_required\n\n\n@login_required(redirect_field_name="my_redirect_field")\ndef my_view(request): ...\n请注意，如果你为 redirect_field_name 提供了一个值，你很可能还需要自定义你的登录模板，因为存储重定向路径的模板上下文变量将使用 redirect_field_name 的值作为其键，而不是（默认值） "next"。
login_required() 还接受一个可选的 login_url 参数。示例：
from django.contrib.auth.decorators import login_required\n\n\n@login_required(login_url="/accounts/login/")\ndef my_view(request): ...\n请注意，如果你没有指定``login_url``参数，你需要确保 settings.LOGIN_URL 和你的登录视图正确关联。例如，使用默认值，将以下行添加到你的 URL 配置文件中：
from django.contrib.auth import views as auth_views\n\npath("accounts/login/", auth_views.LoginView.as_view()),\nsettings.LOGIN_URL 也接受视图函数名称和 命名的 URL 模式。这允许你在 URL 配置中自由重新映射你的登录视图，而无需更新该设置。
LoginRequiredMixin 混合类Link to this heading#当使用 基于类的视图 时，你可以通过使用 LoginRequiredMixin 来实现与 login_required 相同的行为。这个混合类应该在继承列表的最左边位置。
如果一个视图使用了这个混合类，所有非经过身份验证的用户的请求将被重定向到登录页面或显示 HTTP 403 禁止访问的错误，这取决于 raise_exception 参数的设置。
你可以设置 AccessMixin 的任何参数来自定义未经授权用户的处理方式：
from django.contrib.auth.mixins import LoginRequiredMixin\n\n\nclass MyView(LoginRequiredMixin, View):\n login_url = "/login/"\n redirect_field_name = "redirect_to"\nlogin_not_required 装饰器Link to this heading#当安装了 LoginRequiredMiddleware 时，默认情况下所有视图都需要认证。某些视图（例如登录视图）可能需要禁用此行为。
当安装了 LoginRequiredMiddleware 时，允许对此视图进行未经认证的请求。
要基于特定权限或其他测试来限制访问，你可以基本上按照前一节所述的方法进行操作。
\n你可以直接在视图中对 request.user 进行测试。例如，这个视图检查用户是否拥有所需域中的电子邮件，如果没有，就重定向到登录页面：
from django.shortcuts import redirect\n\n\ndef my_view(request):\n if not request.user.email.endswith("@example.com"):\n return redirect("/login/?next=%s" % request.path)\n # ...\n作为一种快捷方式，你可以使用方便的 user_passes_test 装饰器，当可调用对象返回 False 时，它会执行重定向：
from django.contrib.auth.decorators import user_passes_test\n\n\ndef email_check(user):\n return user.email.endswith("@example.com")\n\n\n@user_passes_test(email_check)\ndef my_view(request): ...\nuser_passes_test() 接受一个必需的参数，即一个可调用对象，该对象接受一个 User 对象，并在用户被允许查看页面时返回 True。请注意，user_passes_test() 不会自动检查 User 是否是匿名用户。
user_passes_test() 接受两个可选参数：
login_url允许你指定未通过测试的用户将被重定向到的 URL。如果你没有指定一个 URL，它可能是一个登录页面，并且默认为 settings.LOGIN_URL。
redirect_field_name与 login_required() 类似。将其设置为 None 将其从 URL 中移除，如果你将不通过测试的用户重定向到一个没有 "下一页" 的非登录页面，你可能会想这样做。
例如：
\n@user_passes_test(email_check, login_url="/login/")\ndef my_view(request): ...\n当使用 基于类的视图 时，你可以使用 UserPassesTestMixin 来实现这一点。
你需要重写类的 test_func() 方法来提供要执行的测试。此外，你可以设置 AccessMixin 的任何参数来自定义未经授权用户的处理方式：
from django.contrib.auth.mixins import UserPassesTestMixin\n\n\nclass MyView(UserPassesTestMixin, View):\n def test_func(self):\n return self.request.user.email.endswith("@example.com")\n你还可以重写 get_test_func() 方法，以便混合类使用不同名称的函数进行检查（而不是 test_func()）。
permission_required 装饰器Link to this heading#It's a relatively common task to check whether a user has a particular\npermission. For that reason, Django provides a shortcut for that case: the\npermission_required() decorator:
from django.contrib.auth.decorators import permission_required\n\n\n@permission_required("polls.add_choice")\ndef my_view(request): ...\n就像 has_perm() 方法一样，权限名称采用形式 "<app label>.<permission codename>" （例如，在 polls 应用程序中的模型上的权限为 polls.add_choice ）。
该装饰器还可以接受一个权限的可迭代对象，此时用户必须具备所有这些权限才能访问视图。
\nNote that permission_required()\nalso takes an optional login_url parameter:
from django.contrib.auth.decorators import permission_required\n\n\n@permission_required("polls.add_choice", login_url="/loginpage/")\ndef my_view(request): ...\n与 login_required() 装饰器一样，login_url 默认为 settings.LOGIN_URL。
如果提供了 raise_exception 参数，装饰器将引发 PermissionDenied 异常，而不是重定向到登录页面，从而触发 403（HTTP Forbidden）视图。
如果你想使用 raise_exception，但也想让用户有机会首先登录，你可以添加 login_required() 装饰器：
from django.contrib.auth.decorators import login_required, permission_required\n\n\n@login_required\n@permission_required("polls.add_choice", raise_exception=True)\ndef my_view(request): ...\n这也可以避免在 LoginView 的 redirect_authenticated_user=True 且已登录用户没有所有所需权限时发生重定向循环。
PermissionRequiredMixin MixinLink to this heading#要将权限检查应用于 基于类的视图，你可以使用 PermissionRequiredMixin：
这个混合类，就像 permission_required 装饰器一样，检查访问视图的用户是否具有所有给定的权限。你应该使用 permission_required 参数来指定权限（或权限的可迭代对象）：
from django.contrib.auth.mixins import PermissionRequiredMixin\n\n\nclass MyView(PermissionRequiredMixin, View):\n permission_required = "polls.add_choice"\n # Or multiple of permissions:\n permission_required = ["polls.view_choice", "polls.change_choice"]\n你可以设置 AccessMixin 的任何参数来自定义未经授权用户的处理方式。
你可能同样需要重写这些方法：
\n返回一个被混合类使用的权限名称的可迭代对象。默认为 permission_required 属性，如果需要会将其转换为元组。
Returns a boolean denoting whether the current user has permission to\nexecute the decorated view. By default, this returns the result of\ncalling has_perms() with the\nlist of permissions returned by get_permission_required().
Django 提供了多个视图，你可以用来处理登录、注销和密码管理。这些视图使用了 内置的身份验证表单，但你也可以传入自己的表单。
\nDjango 不提供身份验证视图的默认模板。你应该为想要使用的视图创建自己的模板。模板上下文在每个视图中都有文档记录，详见 所有认证视图。
\n有多种方法可以在项目中实现这些视图。最简单的方法是在你自己的 URL 配置中包含提供的 URLconf，例如：
\nurlpatterns = [\n path("accounts/", include("django.contrib.auth.urls")),\n]\n这将包括以下 URL 模式：
\naccounts/login/ [name='login']\naccounts/logout/ [name='logout']\naccounts/password_change/ [name='password_change']\naccounts/password_change/done/ [name='password_change_done']\naccounts/password_reset/ [name='password_reset']\naccounts/password_reset/done/ [name='password_reset_done']\naccounts/reset/<uidb64>/<token>/ [name='password_reset_confirm']\naccounts/reset/done/ [name='password_reset_complete']\n这些视图提供了一个URL名称，以便更容易引用。有关使用命名URL模式的详细信息，请参阅 URL文档。
\n如果你想要更多控制你的 URL，你可以在你的 URLconf 中引用一个特定的视图：
\nfrom django.contrib.auth import views as auth_views\n\nurlpatterns = [\n path("change-password/", auth_views.PasswordChangeView.as_view()),\n]\n视图有可选参数，你可以使用这些参数来更改视图的行为。例如，如果你想要更改视图使用的模板名称，你可以提供 template_name 参数。一种方法是在 URLconf 中提供关键字参数，这些参数将传递给视图。例如：
urlpatterns = [\n path(\n "change-password/",\n auth_views.PasswordChangeView.as_view(template_name="change-password.html"),\n ),\n]\n所有视图都是 基于类的，这使你可以通过子类化轻松自定义它们。
\n这是所有由 django.contrib.auth 提供的视图列表。有关实现细节，请参阅 使用视图。
URL 名称： login
请参阅 URL 文档 以获取有关使用命名 URL 模式的详细信息。
\n方法和属性
\n用于显示用户登录视图的模板名称。默认为 registration/login.html。
登录后重定向的 URL。默认为 LOGIN_REDIRECT_URL。
包含登录后重定向 URL 的 GET 字段名称。默认为 next。如果传递了给定的 GET 参数，将覆盖 get_default_redirect_url() URL。
用于身份验证的可调用对象（通常是一个表单类）。默认为 AuthenticationForm。
一个包含将添加到传递给模板的默认上下文数据的字典。
\n一个布尔值，控制是否对已经认证的用户访问登录页面进行重定向，就好像他们刚刚成功登录一样。默认为 False。
一个主机集合，用于登录后的重定向，除了 request.get_host()，默认为空 set。
返回登录后重定向的URL。如果设置了默认实现会解析并返回 next_page，否则返回 LOGIN_REDIRECT_URL。
以下是 LoginView 所做的事情：
如果通过 GET 调用，它会显示一个登录表单，该表单将数据 POST 到相同的 URL。稍后会详细介绍这一点。
如果通过用户提交的凭据调用 POST，它会尝试登录用户。如果登录成功，视图将重定向到 next 参数指定的 URL。如果未提供 next，它将重定向到 settings.LOGIN_REDIRECT_URL （默认为 /accounts/profile/ ）。如果登录不成功，它会重新显示登录表单。
你需要提供登录模板的 HTML，默认情况下命名为 registration/login.html。该模板将接收四个模板上下文变量：
form: 一个代表 AuthenticationForm 的 Form 对象。
next: 登录成功后要重定向的 URL。这可能包含查询字符串。
site: 根据 SITE_ID 设置，表示当前的 Site。如果你没有安装站点框架，它将设置为 RequestSite 的实例，该实例从当前的 HttpRequest 获取站点名称和域名。
site_name: 用于别名 site.name。如果你没有安装站点框架，它将设置为 request.META['SERVER_NAME'] 的值。有关站点的更多信息，请参阅 “站点”框架。
如果你不想将模板命名为 registration/login.html，你可以通过额外的参数将 template_name 参数传递给 URLconf 中的 as_view 方法。例如，以下 URLconf 行将使用 myapp/login.html：
path("accounts/login/", auth_views.LoginView.as_view(template_name="myapp/login.html")),\n你还可以使用 redirect_field_name 指定包含登录后重定向 URL 的 GET 字段的名称。默认情况下，该字段称为 next。
以下是一个示例 registration/login.html 模板，你可以将其用作起点。它假定你有一个定义了 content 块的 base.html 模板：
{% extends "base.html" %}\n\n{% block content %}\n\n{% if form.errors %}\n<p>Your username and password didn't match. Please try again.</p>\n{% endif %}\n\n{% if next %}\n {% if user.is_authenticated %}\n <p>Your account doesn't have access to this page. To proceed,\n please login with an account that has access.</p>\n {% else %}\n <p>Please login to see this page.</p>\n {% endif %}\n{% endif %}\n\n<form method="post" action="{% url 'login' %}">\n{% csrf_token %}\n<table>\n<tr>\n <td>{{ form.username.label_tag }}</td>\n <td>{{ form.username }}</td>\n</tr>\n<tr>\n <td>{{ form.password.label_tag }}</td>\n <td>{{ form.password }}</td>\n</tr>\n</table>\n\n<input type="submit" value="login">\n<input type="hidden" name="next" value="{{ next }}">\n</form>\n\n{# Assumes you set up the password_reset view in your URLconf #}\n<p><a href="{% url 'password_reset' %}">Lost password?</a></p>\n\n{% endblock %}\n如果你已经自定义了身份验证（参见 自定义身份验证），你可以通过设置 authentication_form 属性来使用自定义的身份验证表单。这个表单必须在其 __init__() 方法中接受一个 request 关键字参数，并提供一个返回经过身份验证的用户对象的 get_user() 方法（此方法仅在表单验证成功后调用）。
在 POST 请求中登出用户。
URL 名称: logout
属性:
\n登出后重定向的 URL。默认为 LOGOUT_REDIRECT_URL。
在用户注销后显示的模板的全名。默认为 registration/logged_out.html。
GET 字段的名称，包含在登出后重定向的 URL。默认为 'next'。如果传递了给定的 GET 参数，则会覆盖 next_page URL。
一个包含将添加到传递给模板的默认上下文数据的字典。
\n一个 set，除了 request.get_host() 外，用于在注销后安全重定向的主机。默认为空的 set。
模板上下文：
\ntitle：本地化的字符串 "已注销"。
site: 根据 SITE_ID 设置，表示当前的 Site。如果你没有安装站点框架，它将设置为 RequestSite 的实例，该实例从当前的 HttpRequest 获取站点名称和域名。
site_name: 用于别名 site.name。如果你没有安装站点框架，它将设置为 request.META['SERVER_NAME'] 的值。有关站点的更多信息，请参阅 “站点”框架。
在 POST 请求上注销用户，然后重定向到登录页面。
URL 名称： 未提供默认 URL
\n可选参数：
\nlogin_url: 要重定向到的登录页面的 URL。如果未提供，默认为 settings.LOGIN_URL。
URL 名称： password_change
允许用户更改他们的密码。
\n属性:
\n用于显示密码更改表单的模板的完整名称。如果未提供，默认为 registration/password_change_form.html。
在成功更改密码后重定向到的 URL。默认为 'password_change_done'。
一个自定义的“更改密码”表单，必须接受一个 user 关键字参数。该表单负责实际更改用户的密码。默认为 PasswordChangeForm。
一个包含将添加到传递给模板的默认上下文数据的字典。
\n模板上下文：
\nform：密码更改表单（参见上面的 form_class）。
URL 名称： password_change_done
用户成功更改密码后显示的页面。
\n属性:
\n要使用的模板的完整名称。如果未提供，默认为 registration/password_change_done.html。
一个包含将添加到传递给模板的默认上下文数据的字典。
\nURL 名称： password_reset
允许用户通过生成一次性使用的链接来重置密码，并将该链接发送到用户注册的电子邮件地址。
\n如果满足以下条件，此视图将发送电子邮件：
\n提供的电子邮件地址存在于系统中。
所请求的用户处于活动状态（ User.is_active 为 True ）。
所请求的用户具有可用的密码。被标记为不可用密码的用户（参见 set_unusable_password() ）不允许请求密码重置，以防止在使用外部身份验证源如 LDAP 时被滥用。
如果不满足上述任何条件，将不会发送电子邮件，但用户也不会收到任何错误消息。这可以防止信息泄漏给潜在的攻击者。如果您想在这种情况下提供错误消息，可以子类化 PasswordResetForm 并使用 form_class 属性。
属性:
\n要用于显示密码重置表单的模板的完整名称。如果未提供，默认为 registration/password_reset_form.html。
将用于获取要重置密码的用户电子邮件的表单。默认为 PasswordResetForm。
要用于生成带有重置密码链接的电子邮件的模板的完整名称。如果未提供，默认为 registration/password_reset_email.html。
要用于电子邮件主题的模板的完整名称，其中包含重置密码链接。如果未提供，默认为 registration/password_reset_subject.txt。
用于检查一次性链接的类的实例。默认为 default_token_generator，它是 django.contrib.auth.tokens.PasswordResetTokenGenerator 的实例。
在成功重置密码请求后重定向到的 URL。默认为 'password_reset_done'。
有效的电子邮件地址。默认情况下，Django 使用 DEFAULT_FROM_EMAIL。
一个包含将添加到传递给模板的默认上下文数据的字典。
\n用于生成带有密码重置链接的 text/html 多部分电子邮件的模板的完整名称。默认情况下，不会发送 HTML 电子邮件。
\n一个包含在电子邮件模板中可用的上下文数据的字典。它可以用于覆盖下面列出的默认模板上下文值，例如 domain。
模板上下文：
\nform：用于重置用户密码的表单（参见上面的 form_class）。
电子邮件模板上下文：
\nemail ： user.email 的别名
user ：根据 email 表单字段，表示当前的 User。只有活动用户才能重置他们的密码（ User.is_active is True ）。
site_name: 用于别名 site.name。如果你没有安装站点框架，它将设置为 request.META['SERVER_NAME'] 的值。有关站点的更多信息，请参阅 “站点”框架。
domain ：site.domain 的别名。如果你没有安装站点框架，这将设置为 request.get_host() 的值。
protocol ：http 或 https
uid ：使用 base 64 编码过的用户主键。
token ：检测重置密码链接是否有效的 Token 。
示例 registration/password_reset_email.html （电子邮件正文模板）：
Someone asked for password reset for email {{ email }}. Follow the link below:\n{{ protocol}}://{{ domain }}{% url 'password_reset_confirm' uidb64=uid token=token %}\n相同的模板上下文用于主题模板。主题必须是单行纯文本字符串。
\nURL 名称： password_reset_done
在向用户发送了重置密码链接后显示的页面。如果 PasswordResetView 没有显式设置 success_url URL，则默认调用此视图。
属性:
\n要使用的模板的完整名称。如果未提供，默认为 registration/password_reset_done.html。
一个包含将添加到传递给模板的默认上下文数据的字典。
\nURL 名称： password_reset_confirm
提供一个用于输入新密码的表单。
\n来自 URL 的关键字参数：
\nuidb64 ：以 base 64 编码的用户 id。
token ：检查密码是否有效的 Token。
属性:
\n用于显示确认密码视图的模板的完整名称。默认值为 registration/password_reset_confirm.html。
用于检查密码的类的实例。默认为 default_token_generator，它是 django.contrib.auth.tokens.PasswordResetTokenGenerator 的实例。
一个布尔值，指示在成功重置密码后是否应自动对用户进行身份验证。默认为 False。
如果 post_reset_login 为 True，在对用户进行身份验证时要使用的身份验证后端的点路径。只有在配置了多个 AUTHENTICATION_BACKENDS 时才需要。默认为 None。
将用于设置密码的表单。默认为 SetPasswordForm。
密码重置完成后重定向的 URL。默认为 'password_reset_complete'。
一个包含将添加到传递给模板的默认上下文数据的字典。
\n作为密码重置 URL 的一部分显示的令牌参数。默认为 'set-password'。
模板上下文：
\nform：用于设置新用户密码的表单（参见上面的 form_class）。
validlink：布尔值，如果链接（uidb64 和 token 的组合）有效或尚未使用，则为 True。
URL 名称： password_reset_complete
提供一个视图，通知用户密码已成功更改。
\n属性:
\n用于显示视图的模板的完整名称。默认为 registration/password_reset_complete.html。
一个包含将添加到传递给模板的默认上下文数据的字典。
\n重定向到登录页面，登陆成功后跳转到其他 URL 。
\n必要参数
\nnext ：成功登陆后跳转的 URL。
可选参数：
\nlogin_url: 要重定向到的登录页面的 URL。如果未提供，默认为 settings.LOGIN_URL。
redirect_field_name ： GET 字段包含的登录后跳转 URL 的参数名称。如果传递给定的 GET 参数，将会覆盖 next 。
如果您不想使用内置视图，但希望方便地不必编写用于此功能的表单，身份验证系统提供了位于 django.contrib.auth.forms 中的几个内置表单：
这是一个在管理界面中用于更改用户密码的表单，包括设置 不可用密码 的功能，该功能会阻止用户使用基于密码的认证登录。
将 user 作为第一个位置参数。
这是一个在管理界面中用于创建新用户的表单。继承自 UserCreationForm。
It includes an additional usable_password field, enabled by default. If\nusable_password is enabled, it verifies that password1 and\npassword2 are non empty and match, validates the password using\nvalidate_password(), and\nsets the user's password using\nset_password().\nIf usable_password is disabled, no password validation is done, and\npassword-based authentication is disabled for the user by calling\nset_unusable_password().
用于登录用户的表单。
\n将 request 作为其第一个位置参数，该参数存储在表单实例上，供子类使用。
默认情况下，AuthenticationForm 拒绝 is_active 标志设置为 False 的用户。您可以通过自定义策略来确定哪些用户可以登录来覆盖此行为。可以通过创建一个子类化 AuthenticationForm 并覆盖 confirm_login_allowed() 方法的自定义表单来实现这一点。如果给定的用户不允许登录，此方法应引发 ValidationError。
例如，要允许所有用户登录，而不考虑其“active”状态：
\nfrom django.contrib.auth.forms import AuthenticationForm\n\n\nclass AuthenticationFormWithInactiveUsersOkay(AuthenticationForm):\n def confirm_login_allowed(self, user):\n pass\n（在这种情况下，您还需要使用允许不活动用户的身份验证后端，例如 AllowAllUsersModelBackend。）
或者只允许某些活动用户登录：
\nclass PickyAuthenticationForm(AuthenticationForm):\n def confirm_login_allowed(self, user):\n if not user.is_active:\n raise ValidationError(\n _("This account is inactive."),\n code="inactive",\n )\n if user.username.startswith("b"):\n raise ValidationError(\n _("Sorry, accounts starting with 'b' aren't welcome here."),\n code="no_b_users",\n )\n用于创建新用户的 ModelForm。如果您需要自定义用户创建表单，则推荐使用此基类。
It has three fields: username (from the user model), password1,\nand password2. It verifies that password1 and password2 match,\nvalidates the password using\nvalidate_password(), and\nsets the user's password using\nset_password().
用于允许用户更改密码的表单。
\n用于生成并发送一次性使用链接以重置用户密码的表单。
\n使用参数发送 EmailMultiAlternatives。可以重写此方法以自定义如何向用户发送电子邮件。如果你选择重写此方法，请注意处理由于电子邮件发送失败而引发的潜在异常。
subject_template_name -- 主题的模板。
email_template_name -- 电子邮件正文的模板。
context -- 传递给 subject_template、email_template 和 html_email_template （如果不为 None ）的上下文。
from_email -- 发送者的电子邮件地址。
to_email -- 请求者的电子邮件地址。
html_email_template_name -- HTML 正文的模板；默认为 None，在这种情况下发送纯文本电子邮件。
默认情况下，save() 使用与 PasswordResetView 传递给其电子邮件上下文的相同变量填充 context。
一个允许用户在不输入旧密码的情况下更改密码的表单。
\n在管理界面中用于更改用户信息和权限的表单。
\n继承自 BaseUserCreationForm。为了防止与类似的用户名混淆，该表单不允许仅在大小写上不同的用户名。
当您使用 RequestContext 时，当前已登录的用户及其权限将在 模板上下文 中提供。
在渲染模板时， RequestContext 会将当前已登录的用户，可以是 User 实例或 AnonymousUser 实例，存储在模板变量 {{ user }} 中：
{% if user.is_authenticated %}\n <p>Welcome, {{ user.username }}. Thanks for logging in.</p>\n{% else %}\n <p>Welcome, new user. Please log in.</p>\n{% endif %}\n如果未使用 RequestContext，则此模板上下文变量将不可用。
当前已登录用户的权限存储在模板变量 {{ perms }} 中。这是 django.contrib.auth.context_processors.PermWrapper 的一个实例，它是权限的模板友好代理。
将 {{ perms }} 的单属性查找评估为布尔值是 User.has_module_perms() 的代理。例如，要检查已登录用户是否在 foo 应用程序中有任何权限：
{% if perms.foo %}\n将双层属性查找评估为布尔值是 User.has_perm() 的代理。例如，要检查已登录用户是否具有权限 foo.add_vote：
{% if perms.foo.add_vote %}\n以下是在模板中检查权限的更完整的示例：
\n{% if perms.foo %}\n <p>You have permission to do something in the foo app.</p>\n {% if perms.foo.add_vote %}\n <p>You can vote!</p>\n {% endif %}\n {% if perms.foo.add_driving %}\n <p>You can drive!</p>\n {% endif %}\n{% else %}\n <p>You don't have permission to do anything in the foo app.</p>\n{% endif %}\n也可以使用 {% if in %} 语句查找权限。例如：
{% if 'foo' in perms %}\n {% if 'foo.add_vote' in perms %}\n <p>In lookup works, too.</p>\n {% endif %}\n{% endif %}\n当您同时安装了 django.contrib.admin 和 django.contrib.auth 时，管理界面提供了一种方便的方式来查看和管理用户、组和权限。用户可以像任何 Django 模型一样创建和删除。可以创建组，并将权限分配给用户或组。还会存储和显示在管理界面内对模型的用户编辑记录。
你应该在主管理索引页面的 "Auth" 部分看到一个指向 "Users" 的链接。"Add user" 管理页面与标准管理页面不同，因为它要求你在允许编辑用户的其他字段之前选择一个用户名和密码。或者，在此页面上，你可以选择一个用户名并禁用该用户的基于密码的认证。
\n还要注意：如果您希望用户帐户能够使用 Django 管理站点创建用户，您需要为其分配添加用户和更改用户（即“添加用户”和“更改用户”权限）。如果帐户有添加用户的权限但没有更改用户的权限，那么该帐户将无法添加用户。为什么？因为如果您有添加用户的权限，那么您就有了创建超级用户的权力，然后超级用户可以修改其他用户。因此，Django 要求同时具备添加和更改权限作为一种轻微的安全措施。
\n在允许用户管理权限时要谨慎。如果您授予非超级用户编辑用户的权限，这实际上与授予他们超级用户状态相同，因为他们将能够提升用户的权限，包括他们自己！
\n用户密码不会在管理界面中显示（也不会存储在数据库中），但会显示 密码存储详细信息。在此信息的显示中包含一个指向密码更改表单的链接，该表单允许管理员更改或取消设置用户密码。
\n