Django error page 404 - Исправление ошибок и поиск оптимальных решений проблем

Writing views¶

A view function, or view for short, is a Python function that takes a
web request and returns a web response. This response can be the HTML contents
of a web page, or a redirect, or a 404 error, or an XML document, or an image .
. . or anything, really. The view itself contains whatever arbitrary logic is
necessary to return that response. This code can live anywhere you want, as long
as it’s on your Python path. There’s no other requirement–no “magic,” so to
speak. For the sake of putting the code somewhere, the convention is to
put views in a file called views.py, placed in your project or
application directory.

A simple view¶

Here’s a view that returns the current date and time, as an HTML document:

from django.http import HttpResponse
import datetime

def current_datetime(request):
    now = datetime.datetime.now()
    html = "<html><body>It is now %s.</body></html>" % now
    return HttpResponse(html)

Let’s step through this code one line at a time:

First, we import the class HttpResponse from the
django.http module, along with Python’s datetime library.
Next, we define a function called current_datetime. This is the view
function. Each view function takes an HttpRequest
object as its first parameter, which is typically named request.

Note that the name of the view function doesn’t matter; it doesn’t have to
be named in a certain way in order for Django to recognize it. We’re
calling it current_datetime here, because that name clearly indicates
what it does.
The view returns an HttpResponse object that
contains the generated response. Each view function is responsible for
returning an HttpResponse object. (There are
exceptions, but we’ll get to those later.)

Django’s Time Zone

Django includes a TIME_ZONE setting that defaults to
America/Chicago. This probably isn’t where you live, so you might want
to change it in your settings file.

Mapping URLs to views¶

So, to recap, this view function returns an HTML page that includes the current
date and time. To display this view at a particular URL, you’ll need to create a
URLconf; see URL dispatcher for instructions.

Returning errors¶

Django provides help for returning HTTP error codes. There are subclasses of
HttpResponse for a number of common HTTP status codes
other than 200 (which means “OK”). You can find the full list of available
subclasses in the request/response
documentation. Return an instance of one of those subclasses instead of a
normal HttpResponse in order to signify an error. For
example:

from django.http import HttpResponse, HttpResponseNotFound

def my_view(request):
    # ...
    if foo:
        return HttpResponseNotFound('<h1>Page not found</h1>')
    else:
        return HttpResponse('<h1>Page was found</h1>')

There isn’t a specialized subclass for every possible HTTP response code,
since many of them aren’t going to be that common. However, as documented in
the HttpResponse documentation, you can also pass the
HTTP status code into the constructor for HttpResponse
to create a return class for any status code you like. For example:

from django.http import HttpResponse

def my_view(request):
    # ...

    # Return a "created" (201) response code.
    return HttpResponse(status=201)

Because 404 errors are by far the most common HTTP error, there’s an easier way
to handle those errors.

The `Http404` exception¶

class django.http.Http404¶

When you return an error such as HttpResponseNotFound,
you’re responsible for defining the HTML of the resulting error page:

return HttpResponseNotFound('<h1>Page not found</h1>')

For convenience, and because it’s a good idea to have a consistent 404 error page
across your site, Django provides an Http404 exception. If you raise
Http404 at any point in a view function, Django will catch it and return the
standard error page for your application, along with an HTTP error code 404.

Example usage:

from django.http import Http404
from django.shortcuts import render
from polls.models import Poll

def detail(request, poll_id):
    try:
        p = Poll.objects.get(pk=poll_id)
    except Poll.DoesNotExist:
        raise Http404("Poll does not exist")
    return render(request, 'polls/detail.html', {'poll': p})

In order to show customized HTML when Django returns a 404, you can create an
HTML template named 404.html and place it in the top level of your
template tree. This template will then be served when DEBUG is set
to False.

When DEBUG is True, you can provide a message to Http404 and
it will appear in the standard 404 debug template. Use these messages for
debugging purposes; they generally aren’t suitable for use in a production 404
template.

Customizing error views¶

The default error views in Django should suffice for most web applications,
but can easily be overridden if you need any custom behavior. Specify the
handlers as seen below in your URLconf (setting them anywhere else will have no
effect).

The page_not_found() view is overridden by
handler404:

handler404 = 'mysite.views.my_custom_page_not_found_view'

The server_error() view is overridden by
handler500:

handler500 = 'mysite.views.my_custom_error_view'

The permission_denied() view is overridden by
handler403:

handler403 = 'mysite.views.my_custom_permission_denied_view'

The bad_request() view is overridden by
handler400:

handler400 = 'mysite.views.my_custom_bad_request_view'

Testing custom error views¶

To test the response of a custom error handler, raise the appropriate exception
in a test view. For example:

from django.core.exceptions import PermissionDenied
from django.http import HttpResponse
from django.test import SimpleTestCase, override_settings
from django.urls import path


def response_error_handler(request, exception=None):
    return HttpResponse('Error handler content', status=403)


def permission_denied_view(request):
    raise PermissionDenied


urlpatterns = [
    path('403/', permission_denied_view),
]

handler403 = response_error_handler


# ROOT_URLCONF must specify the module that contains handler403 = ...
@override_settings(ROOT_URLCONF=__name__)
class CustomErrorHandlerTests(SimpleTestCase):

    def test_handler_renders_template_response(self):
        response = self.client.get('/403/')
        # Make assertions on the response here. For example:
        self.assertContains(response, 'Error handler content', status_code=403)

Async views¶

As well as being synchronous functions, views can also be asynchronous
(“async”) functions, normally defined using Python’s async def syntax.
Django will automatically detect these and run them in an async context.
However, you will need to use an async server based on ASGI to get their
performance benefits.

Here’s an example of an async view:

import datetime
from django.http import HttpResponse

async def current_datetime(request):
    now = datetime.datetime.now()
    html = '<html><body>It is now %s.</body></html>' % now
    return HttpResponse(html)

You can read more about Django’s async support, and how to best use async
views, in Asynchronous support.

Источник

Getting Help

el
es
fr
id
it
ja
ko
pl
pt-br
zh-hans
Language: en

1.8
1.10
1.11
2.0
2.1
2.2
3.0
3.1
3.2
4.0
4.2
dev
Documentation version:
4.1

Built-in Views¶

Several of Django’s built-in views are documented in
Writing views as well as elsewhere in the documentation.

Serving files in development¶

static.serve(request, path, document_root, show_indexes=False)¶

There may be files other than your project’s static assets that, for
convenience, you’d like to have Django serve for you in local development.
The serve() view can be used to serve any directory
you give it. (This view is not hardened for production use and should be
used only as a development aid; you should serve these files in production
using a real front-end web server).

The most likely example is user-uploaded content in MEDIA_ROOT.
django.contrib.staticfiles is intended for static assets and has no
built-in handling for user-uploaded files, but you can have Django serve your
MEDIA_ROOT by appending something like this to your URLconf:

from django.conf import settings
from django.urls import re_path
from django.views.static import serve

# ... the rest of your URLconf goes here ...

if settings.DEBUG:
    urlpatterns += [
        re_path(r'^media/(?P<path>.*)$', serve, {
            'document_root': settings.MEDIA_ROOT,
        }),
    ]

Note, the snippet assumes your MEDIA_URL has a value of
'media/'. This will call the serve() view,
passing in the path from the URLconf and the (required) document_root
parameter.

Since it can become a bit cumbersome to define this URL pattern, Django
ships with a small URL helper function static()
that takes as parameters the prefix such as MEDIA_URL and a dotted
path to a view, such as 'django.views.static.serve'. Any other function
parameter will be transparently passed to the view.

Error views¶

Django comes with a few views by default for handling HTTP errors. To override
these with your own custom views, see Customizing error views.

The 404 (page not found) view¶

defaults.page_not_found(request, exception, template_name=‘404.html’)¶

When you raise Http404 from within a view, Django loads a
special view devoted to handling 404 errors. By default, it’s the view
django.views.defaults.page_not_found(), which either produces a “Not
Found” message or loads and renders the template 404.html if you created it
in your root template directory.

The default 404 view will pass two variables to the template: request_path,
which is the URL that resulted in the error, and exception, which is a
useful representation of the exception that triggered the view (e.g. containing
any message passed to a specific Http404 instance).

Three things to note about 404 views:

The 404 view is also called if Django doesn’t find a match after
checking every regular expression in the URLconf.
The 404 view is passed a RequestContext and
will have access to variables supplied by your template context
processors (e.g. MEDIA_URL).
If DEBUG is set to True (in your settings module), then
your 404 view will never be used, and your URLconf will be displayed
instead, with some debug information.

The 500 (server error) view¶

defaults.server_error(request, template_name=‘500.html’)¶

Similarly, Django executes special-case behavior in the case of runtime errors
in view code. If a view results in an exception, Django will, by default, call
the view django.views.defaults.server_error, which either produces a
“Server Error” message or loads and renders the template 500.html if you
created it in your root template directory.

The default 500 view passes no variables to the 500.html template and is
rendered with an empty Context to lessen the chance of additional errors.

If DEBUG is set to True (in your settings module), then
your 500 view will never be used, and the traceback will be displayed
instead, with some debug information.

The 403 (HTTP Forbidden) view¶

defaults.permission_denied(request, exception, template_name=‘403.html’)¶

In the same vein as the 404 and 500 views, Django has a view to handle 403
Forbidden errors. If a view results in a 403 exception then Django will, by
default, call the view django.views.defaults.permission_denied.

This view loads and renders the template 403.html in your root template
directory, or if this file does not exist, instead serves the text
“403 Forbidden”, as per RFC 7231#section-6.5.3 (the HTTP 1.1 Specification).
The template context contains exception, which is the string
representation of the exception that triggered the view.

django.views.defaults.permission_denied is triggered by a
PermissionDenied exception. To deny access in a
view you can use code like this:

from django.core.exceptions import PermissionDenied

def edit(request, pk):
    if not request.user.is_staff:
        raise PermissionDenied
    # ...

The 400 (bad request) view¶

defaults.bad_request(request, exception, template_name=‘400.html’)¶

When a SuspiciousOperation is raised in Django,
it may be handled by a component of Django (for example resetting the session
data). If not specifically handled, Django will consider the current request a
‘bad request’ instead of a server error.

django.views.defaults.bad_request, is otherwise very similar to the
server_error view, but returns with the status code 400 indicating that
the error condition was the result of a client operation. By default, nothing
related to the exception that triggered the view is passed to the template
context, as the exception message might contain sensitive information like
filesystem paths.

bad_request views are also only used when DEBUG is False.

Источник

{% load static %}

<!DOCTYPE html>

<html class="no-js" lang="en">

<head>

<meta charset="utf-8">

<title>Web Developer</title>

<link href="{% static 'img/Demo/favicon.png' %}" rel="shortcut icon"/>

<meta charset="UTF-8" />

<meta http-equiv="X-UA-Compatible" content="IE=edge">

<meta name="description" content="Alphaandroid - Creative Agency of web developers">

<meta name="author" content="Pavan And Romil">

<meta name="keywords" content="Web developer (using coding), Digital Marketing" />

<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">

<link rel="stylesheet" href="{% static 'css/error404/base.css' %}">

<link rel="stylesheet" href="{% static 'css/error404/main.css' %}">

<link rel="stylesheet" href="{% static 'css/error404/vendor.css' %}">

<script src="{% static 'js/error404/modernizr.js' %}"></script>

<link rel="icon" type="image/png" href="{% static 'favicon.png' %}">

<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':

new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],

j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=

})(window,document,'script','dataLayer','GTM-MRJ5QRJ');

</script>

</head>

<body>

height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>

{% comment %}

<header class="main-header">

<div class="row">

<div class="logo">

<a href="index.html">Alpha Android</a>

</div>

<a class="menu-toggle" href="#"><span>Menu</span></a>

</header>

{% endcomment %}

{% comment %}

<nav id="menu-nav-wrap">

<h5>Site Pages</h5>

<ul class="nav-list">

<li><a href="/" title="">Home</a></li>

<li><a href="#" title="">About</a></li>

<li><a href="#" title="">Contact</a></li>

</ul>

<h5>Some Text</h5>

<p>Lorem ipsum Non non Duis adipisicing pariatur eu enim Ut in aliqua dolor esse sed est in sit exercitation eiusmod aliquip consequat.</p>

</nav>

{% endcomment %}

<main id="main-404-content" class="main-content-particle-js">

<div class="content-wrap">

<div class="shadow-overlay"></div>

<div class="main-content">

<div class="row">

<div class="col-twelve">

<h1 class="kern-this">404 Error.</h1>

<p>

Oooooops! Looks like nothing was found at this location.

Maybe try on of the links below, click on the top menu

or try a search?

</p>

{% comment %}

<div class="search">

<form>

<input type="text" id="s" name="s" class="search-field" placeholder="Type and hit enter …">

</form>

</div>

{% endcomment %}

</div>

<footer>

<div class="row">

<div class="col-seven tab-full social-links pull-right">

<ul>

<li><a href="#"><i class="fa fa-facebook"></i></a></li>

<li><a href="#"><i class="fa fa-behance"></i></a></li>

<li><a href="#"><i class="fa fa-twitter"></i></a></li>

<li><a href="#"><i class="fa fa-dribbble"></i></a></li>

<li><a href="#"><i class="fa fa-instagram"></i></a></li>

</ul>

</div>

<div class="col-five tab-full bottom-links">

<ul class="links">

<li><a href="/">Homepage</a></li>

<li><a href="/about-us/">About Us</a></li>

{% comment %}

<li><a href="/contact-us/">Contact Us</a></li>

{% endcomment %}

<li><a href="mailto:Contact@alphaandroid.com">Report Error</a></li>

</ul>

<div class="credits">

</div>

</footer>

</div>

</main>

<div id="preloader">

<div id="loader"></div>

</div>

<script src="{% static 'js/error404/jquery-2.1.3.min.js' %}"></script>

<script src="{% static 'js/error404/plugins.js' %}"></script>

<script src="{% static 'js/error404/main.js' %}"></script>

</body>

</html>

Источник

Following the tutorial found here exactly, I cannot create a custom 500 or 404 error page. If I do type in a bad url, the page gives me the default error page. Is there anything I should be checking for that would prevent a custom page from showing up?

File directories:

mysite/
    mysite/
        __init__.py
        __init__.pyc
        settings.py
        settings.pyc
        urls.py
        urls.pyc
        wsgi.py
        wsgi.pyc
    polls/
        templates/
            admin/
                base_site.html
            404.html
            500.html
            polls/
                detail.html
                index.html
        __init__.py
        __init__.pyc
        admin.py
        admin.pyc
        models.py
        models.pyc
        tests.py
        urls.py
        urls.pyc
        view.py
        views.pyc
    templates/
    manage.py

within mysite/settings.py I have these enabled:

DEBUG = False
TEMPLATE_DEBUG = DEBUG

#....

TEMPLATE_DIRS = (
    'C:/Users/Me/Django/mysite/templates', 
)

within mysite/polls/urls.py:

from django.conf.urls import patterns, url

from polls import views

urlpatterns = patterns('',
    url(r'^$', views.index, name='index'),
    url(r'^(?P<poll_id>d+)/$', views.detail, name='detail'),
    url(r'^(?P<poll_id>d+)/results/$', views.results, name='results'),
    url(r'^(?P<poll_id>d+)/vote/$', views.vote, name='vote'),
)

I can post any other code necessary, but what should I be changing to get a custom 500 error page if I use a bad url?

vvvvv

21.1k17 gold badges46 silver badges66 bronze badges

asked Jul 15, 2013 at 20:07

Under your main views.py add your own custom implementation of the following two views, and just set up the templates 404.html and 500.html with what you want to display.

With this solution, no custom code needs to be added to urls.py

Here’s the code:

from django.shortcuts import render_to_response
from django.template import RequestContext


def handler404(request, *args, **argv):
    response = render_to_response('404.html', {},
                                  context_instance=RequestContext(request))
    response.status_code = 404
    return response


def handler500(request, *args, **argv):
    response = render_to_response('500.html', {},
                                  context_instance=RequestContext(request))
    response.status_code = 500
    return response

Update

handler404 and handler500 are exported Django string configuration variables found in django/conf/urls/__init__.py. That is why the above config works.

To get the above config to work, you should define the following variables in your urls.py file and point the exported Django variables to the string Python path of where these Django functional views are defined, like so:

# project/urls.py

handler404 = 'my_app.views.handler404'
handler500 = 'my_app.views.handler500'

Update for Django 2.0

Signatures for handler views were changed in Django 2.0:
https://docs.djangoproject.com/en/2.0/ref/views/#error-views

If you use views as above, handler404 will fail with message:

«handler404() got an unexpected keyword argument ‘exception'»

In such case modify your views like this:

def handler404(request, exception, template_name="404.html"):
    response = render_to_response(template_name)
    response.status_code = 404
    return response

answered Jul 13, 2014 at 16:56

Aaron LelevierAaron Lelevier

19.3k11 gold badges75 silver badges110 bronze badges

Official answer:

Here is the link to the official documentation on how to set up custom error views:

https://docs.djangoproject.com/en/stable/topics/http/views/#customizing-error-views

It says to add lines like these in your URLconf (setting them anywhere else will have no effect):

handler404 = 'mysite.views.my_custom_page_not_found_view'
handler500 = 'mysite.views.my_custom_error_view'
handler403 = 'mysite.views.my_custom_permission_denied_view'
handler400 = 'mysite.views.my_custom_bad_request_view'

You can also customise the CSRF error view by modifying the setting CSRF_FAILURE_VIEW.

Default error handlers:

It’s worth reading the documentation of the default error handlers, page_not_found, server_error, permission_denied and bad_request. By default, they use these templates if they can find them, respectively: 404.html, 500.html, 403.html, and 400.html.

So if all you want to do is make pretty error pages, just create those files in a TEMPLATE_DIRS directory, you don’t need to edit URLConf at all. Read the documentation to see which context variables are available.

In Django 1.10 and later, the default CSRF error view uses the template 403_csrf.html.

Gotcha:

Don’t forget that DEBUG must be set to False for these to work, otherwise, the normal debug handlers will be used.

answered Jun 3, 2016 at 9:52

FlimmFlimm

129k44 gold badges244 silver badges254 bronze badges

Add these lines in urls.py

urls.py

from django.conf.urls import (
handler400, handler403, handler404, handler500
)

handler400 = 'my_app.views.bad_request'
handler403 = 'my_app.views.permission_denied'
handler404 = 'my_app.views.page_not_found'
handler500 = 'my_app.views.server_error'

# ...

and implement our custom views in views.py.

views.py

from django.shortcuts import (
render_to_response
)
from django.template import RequestContext

# HTTP Error 400
def bad_request(request):
    response = render_to_response(
        '400.html',
        context_instance=RequestContext(request)
        )

        response.status_code = 400

        return response

# ...

answered Oct 26, 2015 at 10:03

ArmanceArmance

5,30014 gold badges56 silver badges79 bronze badges

Django 3.0+ 4.0+

here is link how to customize error views

here is link how to render a view

in the urls.py (the main one, in project folder), put:

handler404 = 'my_app_name.views.custom_page_not_found_view'
handler500 = 'my_app_name.views.custom_error_view'
handler403 = 'my_app_name.views.custom_permission_denied_view'
handler400 = 'my_app_name.views.custom_bad_request_view'

and in the mentioned app (my_app_name) put in the views.py:

def custom_page_not_found_view(request, exception):
    return render(request, "errors/404.html", {})

def custom_error_view(request, exception=None):
    return render(request, "errors/500.html", {})

def custom_permission_denied_view(request, exception=None):
    return render(request, "errors/403.html", {})

def custom_bad_request_view(request, exception=None):
    return render(request, "errors/400.html", {})

NOTE: errors/404.html is the path if you place your files into the projects (not the apps) template foldertemplates/errors/404.html so please place the files where you want and write the right path.

NOTE 2: After page reload, if you still see the old template, change in settings.py DEBUG=True, save it, and then again to False and save again (that will restart the server and collect the new files).

answered Mar 31, 2020 at 20:00

elano7elano7

1,1561 gold badge15 silver badges16 bronze badges

From the page you referenced:

When you raise Http404 from within a view, Django will load a special view devoted to handling 404 errors. It finds it by looking for the variable handler404 in your root URLconf (and only in your root URLconf; setting handler404 anywhere else will have no effect), which is a string in Python dotted syntax – the same format the normal URLconf callbacks use. A 404 view itself has nothing special: It’s just a normal view.

So I believe you need to add something like this to your urls.py:

handler404 = 'views.my_404_view'

and similar for handler500.

answered Jul 15, 2013 at 20:13

Mike PelleyMike Pelley

2,90121 silver badges23 bronze badges

If all you need is to show custom pages which have some fancy error messages for your site when DEBUG = False, then add two templates named 404.html and 500.html in your templates directory and it will automatically pick up this custom pages when a 404 or 500 is raised.

answered Dec 1, 2016 at 4:54

In Django 3.x, the accepted answer won’t work because render_to_response has been removed completely as well as some more changes have been made since the version the accepted answer worked for.

Some other answers are also there but I’m presenting a little cleaner answer:

In your main urls.py file:

handler404 = 'yourapp.views.handler404'
handler500 = 'yourapp.views.handler500'

In yourapp/views.py file:

def handler404(request, exception):
    context = {}
    response = render(request, "pages/errors/404.html", context=context)
    response.status_code = 404
    return response


def handler500(request):
    context = {}
    response = render(request, "pages/errors/500.html", context=context)
    response.status_code = 500
    return response

Ensure that you have imported render() in yourapp/views.py file:

from django.shortcuts import render

Side note: render_to_response() was deprecated in Django 2.x and it has been completely removed in verision 3.x.

answered Feb 20, 2020 at 11:19

RehmatRehmat

4,5613 gold badges21 silver badges38 bronze badges

No additional view is required. https://docs.djangoproject.com/en/3.0/ref/views/

Just put the error files in the root of templates directory

404.html
400.html
403.html
500.html

And it should use your error page when debug is False

answered May 19, 2020 at 13:10

Anuj TBEAnuj TBE

8,72023 gold badges127 silver badges269 bronze badges

settings.py:

DEBUG = False
TEMPLATE_DEBUG = DEBUG
ALLOWED_HOSTS = ['localhost']  #provide your host name

and just add your 404.html and 500.html pages in templates folder.
remove 404.html and 500.html from templates in polls app.

Paolo

19.3k21 gold badges75 silver badges113 bronze badges

answered Mar 3, 2016 at 10:58

Rakesh babuRakesh babu

3156 silver badges11 bronze badges

In Django 2.* you can use this construction in views.py

def handler404(request, exception):
    return render(request, 'errors/404.html', locals())

In settings.py

DEBUG = False

if DEBUG is False:
    ALLOWED_HOSTS = [
        '127.0.0.1:8000',
        '*',
    ]

if DEBUG is True:
    ALLOWED_HOSTS = []

In urls.py

# https://docs.djangoproject.com/en/2.0/topics/http/views/#customizing-error-views
handler404 = 'YOUR_APP_NAME.views.handler404'

Usually i creating default_app and handle site-wide errors, context processors in it.

answered Feb 26, 2018 at 8:38

DenisDenis

6591 gold badge9 silver badges21 bronze badges

Make an error, on the error page find out from where django is loading templates. I mean the path stack. In base template_dir add these html pages 500.html , 404.html. When these errors occur the respective template files will be automatically loaded.

You can add pages for other error codes too, like 400 and 403.

vvvvv

21.1k17 gold badges46 silver badges66 bronze badges

answered Aug 17, 2016 at 9:42

ALLSYEDALLSYED

1,46317 silver badges15 bronze badges

As one single line (for 404 generic page):

from django.shortcuts import render_to_response
from django.template import RequestContext

return render_to_response('error/404.html', {'exception': ex},
                                      context_instance=RequestContext(request), status=404)

Francois

5054 silver badges14 bronze badges

answered May 4, 2015 at 13:07

FireZenkFireZenk

9961 gold badge17 silver badges28 bronze badges

# views.py
def handler404(request, exception):
    context = RequestContext(request)
    err_code = 404
    response = render_to_response('404.html', {"code":err_code}, context)
    response.status_code = 404
    return response

# <project_folder>.urls.py
handler404 = 'todo.views.handler404'

This works on django 2.0

Be sure to include your custom 404.html inside the app templates folder.

ayhan

68.1k18 gold badges177 silver badges195 bronze badges

answered Jun 30, 2018 at 7:58

ENDEESAENDEESA

2,9682 gold badges19 silver badges17 bronze badges

Try moving your error templates to .../Django/mysite/templates/.

I am note sure about this one, but I think these need to be «global» to the website.

vvvvv

21.1k17 gold badges46 silver badges66 bronze badges

answered Jul 15, 2013 at 20:16

astrognocciastrognocci

1,0577 silver badges16 bronze badges

In Django root urls.py file, add the below lines

from django.conf.urls import (handler400, handler403, handler404, handler500)

handler400 = 'app.views.bad_request'
handler403 = 'app.views.permission_denied'
handler404 = 'app.views.page_not_found'
handler500 = 'app.views.server_error'

In your app’s views.py file, create the respective functions.

def server_error(request, exception=None):
    # return render(request, '500.html')
    return redirect('/')

Finally, in your settings.py file, set DEBUG = False

answered Jan 28, 2022 at 7:12

I had an additional

TEMPLATE_DIRS

within my settings.py and that was causing the problem.

_{This answer was posted as an edit to the question Django, creating a custom 500/404 error page by the OP reZach under CC BY-SA 3.0.}

answered Dec 22, 2022 at 9:44

vvvvvvvvvv

21.1k17 gold badges46 silver badges66 bronze badges

In urls.py, enter this code:

from django.conf.urls import (handler400, handler403, handler404, handler500)

handler404 = 'my_app.views.page_not_found_view'

then add this code in your views.py

from django.shortcuts import render,get_object_or_404
def page_not_found_view(request, exception):
    return render(request, '404.html', status=404)

Dont forget to set DEBUG = False and also set ALLOWED_HOSTS = [127.0.0.1] while you are testing in your laptop.

vvvvv

21.1k17 gold badges46 silver badges66 bronze badges

answered May 23, 2022 at 8:40

MajidMajid

13 bronze badges

You don’t need to do anything fancy, just create a 404.html file in your templates. Go to settings.py and set:

DEBUG = False
ALLOWED_HOSTS = ["*"]

It will automatically overwrite the default.

vvvvv

21.1k17 gold badges46 silver badges66 bronze badges

answered Dec 14, 2022 at 1:57

Django > 2.2

from django.shortcuts import render_to_response, render
from django.template import RequestContext
def handler500(request, *args, **argv):
    context = {}
    print(request.body, '==========')
    response = render(request, '500.jinja', context=context)
    response.status_code = 500
    return response

in urls.py

handler500 = 'apps.core.views.handler500'

answered Dec 30, 2022 at 14:58

Источник

Page Not Found

If you try to access a page that does not exist (a 404 error), Django directs you to a built-in view that handles 404 errors.

You will learn how to customize this 404 view later in this chapter, but
first, just try to request a page that does not exist.

In the browser window, type 127.0.0.1:8000/masfdfg/ in the address bar.

You will get one of two results:

If you got the first result, you got directed to the built-in Django 404
template.

If you got the second result, then DEBUG is
set to True in your settings, and you must set it to False to get directed to
the 404 template.

This is done in the settings.py file, which
is located in the
project folder, in our case the my_tennis_club folder,
where you also have to specify the host name from where your project runs from:

Example

Set the debug property to False, and allow the project to run from your local
host:

my_tennis_club/my_tennis_club/settings.py:

.
.
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = False

ALLOWED_HOSTS = ['*']
.
.

Important: When DEBUG = False, Django requires you to specify the hosts you will allow this
Django project to run from.

In production, this should be replaced with a proper domain name:

ALLOWED_HOSTS = ['yourdomain.com']

In the browser window, type
127.0.0.1:8000/masfdfg/
in the address bar, and you will get the built-in 404 template:

Customize the 404 Template

Django will look for a file named 404.html in the
templates folder, and display it when there is a 404 error.

If no such file exists, Django shows the «Not Found» that you saw in the
example above.

To customize this message, all you have to do is to create a file in the templates folder and name it
404.html, and fill it with write whatever you
want:

my_tennis_club/members/templates/404.html:

<!DOCTYPE html>
<html>
<title>Wrong address</title>
<body>

<h1>Ooops!</h1>

<h2>I cannot
find the file you requested!</h2>

</body>
</html>

In the browser window, type
127.0.0.1:8000/masfdfg/
in the address bar, and you will get the customized 404 template:

Источник

Home
Django 1.10 Tutorial
Showing 404 errors In Django

Last updated on July 27, 2020

Visit a category page which doesn’t exist for example, http://127.0.0.1:8000/category/cat_not_exists/. You should see DoesNotExist exception like this:

As there is no such category in the database the URL http://127.0.0.1:8000/blog/category/cat_not_exists/ is completely invalid. In production (i.e when DEBUG=True), instead of throwing a DoesNotExist exception Django will show 500 Internal Server Error.

From the point of view of Search Engine Optimization (SEO), it would be much better to show an HTTP 404 error for the non-existent page instead of showing Internal Server Error or DoesNotExist exception.

The same problem exists in the tag page and the post detail page. Visit any tag or post detail page which doesn’t exist like http://127.0.0.1:8000/tag/tag_not_exists/ or http://127.0.0.1:8000/97712/ and see it yourself.

Showing an HTTP 404 page #

Django provides two ways to show 404 error.

HttpResponseNotFound class
Http404 exception

Let’s start with HttpResponseNotFound class.

HttpResponseNotFound class #

The HttpResponseNotFound class is an extension of HttpResponse class. It works just like HttpResponse but instead of returning a 200 status code , it returns 404 (which means page not found). To see how it works, open views.py and modify the post_detail() view as follows:

TGDB/django_project/blog/views.py

from django.http import HttpResponse, HttpResponseNotFound
#...


# view function to display a single post
def post_detail(request, pk):
    try:
        post = Post.objects.get(pk=pk)
    except Post.DoesNotExist:
        return HttpResponseNotFound("Page not found")

    return render(request, 'blog/post_detail.html', {'post': post})
#...

Here we are wrapping the code which might throw an exception in the try and except block. Now, If get() method throws a DoesNotExist exception then instead of displaying an error page, Django will show a 404 error page with "Page not found" response. Save the changes and visit http://127.0.0.1:8000/99999/, you should get a response like this:

Http404 exception #

Another way to show a 404 error page is to raise Http404 exception. Notice that unlike HttpResponseNotFound class, Http404 is an exception. Http404 uses a default 404 page which Django provides. To use it just raise Http404 exception in your code like this:

You can also provide an error message while raising Http404 exception.

raise Http404("Some error message")

Open views.py file and amend post_detail() view as follows:

TGDB/django_project/blog/views.py

from django.http import HttpResponse, HttpResponseNotFound, Http404
#...


# view function to display a single post
def post_detail(request, pk):
    try:
        post = Post.objects.get(pk=pk)
    except Post.DoesNotExist:
        raise Http404("Post not found")

    return render(request, 'blog/post_detail.html', {'post': post})
#...

Save the file and visit http://127.0.0.1:8000/blog/99999/, you will see the following 404 error page.

We are currently in development mode. In production (i.e when DEBUG=False) Django will show 404 page which looks like this:

The get_object_or_404() method #

Most of the time our views function goes like this:

Code try and except block.
Query the database in the try block.
If an exception is thrown, catch the exception in the except block and show a 404 page.

This pattern is so common that Django a provides a shortcurt method called get_object_or_404(). Here is the syntax of get_object_or_404().

Syntax: get_object_or_404(klass, **kwargs)

The klass can be a model, a manager or a Queryset object.

The **kwargs represents all keyword arguments as well as lookup parameters that we have been using with the get() and filter() method.

On success, it returns a single object of the given model, if it can’t find any records then it raises a Http404 exception.

Internally this method calls get() method of objects manager, so you must always use this method to get a single record.

To use get_object_or_404() first import it from django.shortcuts using the following code.

from django.shortcuts import get_object_or_404

The following examples shows how to use get_object_or_404() method with models, queryset and managers. It also shows that when a matching record is not found, get_object_or_404() raises a Http404 exception.

Example 1: where klass is model

>>>
>>> from django.shortcuts import get_object_or_404
>>> from blog.models import Category, Post, Tag, Author
>>> post = get_object_or_404(Post, pk=1)
>>>
>>> post
<Post: Post 1>
>>>
>>>
>>> post = get_object_or_404(Post, pk=990)
Traceback (most recent call last):
...
django.http.response.Http404: No Post matches the given query.
>>>
>>>

The above code is equivalent to:

>>>
>>> try:
...   post = Post.objects.get(pk=1)
... except Post.DoesNotExist:
...   raise Http404("Post not found")
...
>>>

Example 2: where klass is queryset

>>>
>>> queryset = Post.objects.filter(title__contains="Post 1")
>>> queryset
<QuerySet [<Post: Post 1>]>
>>>
>>> post = get_object_or_404(queryset, pk=1)
>>>
>>> post
<Post: Post 1>

>>>
>>>
>>> post = get_object_or_404(queryset, pk=10)   # get_object_or_404() will now raise an exception
Traceback (most recent call last):
  ...
    raise Http404('No %s matches the given query.' % queryset.model._meta.object
_name)
django.http.response.Http404: No Post matches the given query.
>>>
>>>

Example 3: where klass is manager

>>>
>>> c = Category.objects.get(name='java')
>>> c
<Category: java>

>>>
>>> post = get_object_or_404(c.post_set, title__contains="Post 2")
>>>
>>> post
<Post: Post 2>
>>>
>>>
>>> post = get_object_or_404(c.post_set, title__contains="tagged")
Traceback (most recent call last):
...
    raise Http404('No %s matches the given query.' % queryset.model._meta.object_name)
django.http.response.Http404: No Post matches the given query.
>>>
>>>

Let’s update our post_detail() view to use get_object_or_404() method.

TGDB/django_project/blog/views.py

#...
from django.shortcuts import render, get_object_or_404
#...

# view function to display a single post
def post_detail(request, pk):
    post = get_object_or_404(Post, pk=pk)
    return render(request, 'blog/post_detail.html', {'post': post})
#...

The get_list_or_404() method #

The get_list_or_404() works just like get_object_or_404() method, but instead of returning a single result, it returns a queryset object. If no matching results found, it raises a Http404 exception.

Open views.py file and update post_by_category() and post_by_tag() view functions to use get_list_or_404() method as follows:

TGDB/django_project/blog/views.py

#...
from django.shortcuts import render, get_object_or_404, get_list_or_404
#...


# view function to display post by category
def post_by_category(request, category_slug):
    category = get_object_or_404(Category, slug=category_slug)
    posts = get_list_or_404(Post, category=category)
    context = {
        'category': category,
        'posts': posts
    }
    return render(request, 'blog/post_by_category.html', context)


# view function to display post by tag
def post_by_tag(request, tag_slug):
    tag = get_object_or_404(Tag, slug=tag_slug)
    posts = get_list_or_404(Post, tags=tag)
    context = {
        'tag': tag,
        'posts': posts,
    }
    return render(request, 'blog/post_by_tag.html', context )

After updating views, visit any non-existent category page, tag page or post detail page, you should get a proper HTTP 404 error.

Creating SEO friendly URLs #

As the situation stands, our post detail page URLs looks like http://127.0.0.1:8000/6/. Although it is working fine, the problem is that by looking at the URL nobody can tell what the post is about. It would be good to create URLs which describes something about the post.

For our blog, we will create a URL pattern like the following:

http://example.com/post-pk/post-slug

Let’s implement this URL pattern.

Open urls.py in the blog app and amend post_detail URL pattern as follows:

TGDB/django_project/blog/urls.py

#...

urlpatterns = [
    url(r'^category/(?P<category_slug>[w-]+)/$', views.post_by_category, name='post_by_category'),
    url(r'^tag/(?P<tag_slug>[w-]+)/$', views.post_by_tag, name='post_by_tag'),
    url(r'^(?P<pk>d+)/(?P<post_slug>[wd-]+)$', views.post_detail, name='post_detail'),
    url(r'^$', views.post_list, name='post_list'),
]

Update post_detail() view function to accept another parameter called post_slug as follows:

TGDB/django_project/blog/views.py

#...

# view function to display a single post
def post_detail(request, pk, post_slug):
    post = get_object_or_404(Post, pk=pk)
    return render(request, 'blog/post_detail.html', {'post': post})

#...

At last, we need to modify the get_absolute_url() method of the Post model. Open models.py and update get_absolute_url() method of Post model as follows:

TGDB/django_project/blog/models.py

#...
class Post(models.Model):
    #...
    def get_absolute_url(self):
        return reverse('post_detail', args=[self.id, self.slug])
#...

As we are using get_absolute_url() method to generate links to post detail page in our templates, we don’t need to modify anything else. All templates will pick the changes automatically.

To view the updated URL visit http://127.0.0.1:8000/ and click on any post detail page.

Listing posts in reverse chronological order #

Currently, all pages of our site display posts in the order in which they are inserted into the database. For usability purpose, it would be much better to display posts in reverse chronological order i.e latest first, oldest last.

This change would be very simple. Open views.py in the blog app and update post_list(), post_by_category() and post_by_tag() views as follows:

TGDB/django_project/blog/views.py

#...

# view function to display a list of posts
def post_list(request):
    posts = Post.objects.order_by("-id").all()
    return render(request, 'blog/post_list.html', {'posts': posts})


# view function to display a single post
def post_detail(request, pk, post_slug):
    post = get_object_or_404(Post, pk=pk)
    return render(request, 'blog/post_detail.html', {'post': post})


# view function to display post by category    
def post_by_category(request, category):
    category = get_object_or_404(Category, slug=category_slug)
    posts = get_list_or_404(Post.objects.order_by("-id"), category=category)
    context = {
        'category': category,
        'posts': posts
    }
    return render(request, 'blog/post_by_category.html', context)


# view function to display post by tag
def post_by_tag(request, tag):
    tag = get_object_or_404(Tag, slug=tag_slug)
    posts = get_list_or_404(Post.objects.order_by("-id"), tags=tag)
    context = {
        'tag': tag,
        'posts': posts
    }
    return render(request, 'blog/post_by_tag.html', context )

From now on, all the pages of our blog will display posts in reverse chronological order.

Note: To checkout this version of the repository type git checkout 18a.

Источник

Writing views¶

A simple view¶

Mapping URLs to views¶

Returning errors¶

The Http404 exception¶

Customizing error views¶

Testing custom error views¶

Async views¶

Built-in Views¶

Serving files in development¶

Error views¶

The 404 (page not found) view¶

The 500 (server error) view¶

The 403 (HTTP Forbidden) view¶

The 400 (bad request) view¶

Official answer:

Default error handlers:

Gotcha:

urls.py

views.py

Page Not Found

Example

Customize the 404 Template

Showing an HTTP 404 page #

HttpResponseNotFound class #

Http404 exception #

The get_object_or_404() method #

The get_list_or_404() method #

Creating SEO friendly URLs #

Listing posts in reverse chronological order #

The `Http404` exception¶