Django2.0手册:The sitemap framework



Django comes with a high-level sitemap-generating framework that makes
creating sitemap XML files easy.

Overview¶

A sitemap is an XML file on your website that tells search-engine indexers how
frequently your pages change and how “important” certain pages are in relation
to other pages on your site. This information helps search engines index your
site.

The Django sitemap framework automates the creation of this XML file by letting
you express this information in Python code.

It works much like Django’s syndication framework. To create a sitemap, just write a
Sitemap class and point to it in your
URLconf.

Installation¶

To install the sitemap app, follow these steps:

  1. Add 'django.contrib.sitemaps' to your INSTALLED_APPS
    setting.
  2. Make sure your TEMPLATES setting contains a DjangoTemplates
    backend whose APP_DIRS options is set to True. It’s in there by
    default, so you’ll only need to change this if you’ve changed that setting.
  3. Make sure you’ve installed the
    sites framework.

(Note: The sitemap application doesn’t install any database tables. The only
reason it needs to go into INSTALLED_APPS is so that the
Loader() template
loader can find the default templates.)

Initialization¶

views.sitemap(request, sitemaps, section=None, template_name=’sitemap.xml’, content_type=’application/xml’)

To activate sitemap generation on your Django site, add this line to your
URLconf:

from django.contrib.sitemaps.views import sitemap

path('sitemap.xml', sitemap, {'sitemaps': sitemaps},
     name='django.contrib.sitemaps.views.sitemap')

This tells Django to build a sitemap when a client accesses /sitemap.xml.

The name of the sitemap file is not important, but the location is. Search
engines will only index links in your sitemap for the current URL level and
below. For instance, if sitemap.xml lives in your root directory, it may
reference any URL in your site. However, if your sitemap lives at
/content/sitemap.xml, it may only reference URLs that begin with
/content/.

The sitemap view takes an extra, required argument: {'sitemaps': sitemaps}.
sitemaps should be a dictionary that maps a short section label (e.g.,
blog or news) to its Sitemap class
(e.g., BlogSitemap or NewsSitemap). It may also map to an instance of
a Sitemap class (e.g.,
BlogSitemap(some_var)).

Sitemap classes¶

A Sitemap class is a simple Python
class that represents a “section” of entries in your sitemap. For example,
one Sitemap class could represent
all the entries of your Weblog, while another could represent all of the
events in your events calendar.

In the simplest case, all these sections get lumped together into one
sitemap.xml, but it’s also possible to use the framework to generate a
sitemap index that references individual sitemap files, one per section. (See
Creating a sitemap index below.)

Sitemap classes must subclass
django.contrib.sitemaps.Sitemap. They can live anywhere in your codebase.

A simple example¶

Let’s assume you have a blog system, with an Entry model, and you want your
sitemap to include all the links to your individual blog entries. Here’s how
your sitemap class might look:

from django.contrib.sitemaps import Sitemap
from blog.models import Entry

class BlogSitemap(Sitemap):
    changefreq = "never"
    priority = 0.5

    def items(self):
        return Entry.objects.filter(is_draft=False)

    def lastmod(self, obj):
        return obj.pub_date

Note:

  • changefreq and priority are class
    attributes corresponding to <changefreq> and <priority> elements,
    respectively. They can be made callable as functions, as
    lastmod was in the example.
  • items() is simply a method that returns a list of
    objects. The objects returned will get passed to any callable methods
    corresponding to a sitemap property (location,
    lastmod, changefreq, and
    priority).
  • lastmod should return a datetime.
  • There is no location method in this example, but you
    can provide it in order to specify the URL for your object. By default,
    location() calls get_absolute_url() on each object
    and returns the result.

Sitemap class reference¶

class Sitemap[source]

A Sitemap class can define the following methods/attributes:

items[source]

Required. A method that returns a list of objects. The framework
doesn’t care what type of objects they are; all that matters is that
these objects get passed to the location(),
lastmod(), changefreq() and
priority() methods.

location[source]

Optional. Either a method or attribute.

If it’s a method, it should return the absolute path for a given object
as returned by items().

If it’s an attribute, its value should be a string representing an
absolute path to use for every object returned by
items().

In both cases, “absolute path” means a URL that doesn’t include the
protocol or domain. Examples:

  • Good: '/foo/bar/'
  • Bad: 'example.com/foo/bar/'
  • Bad: 'https://example.com/foo/bar/'

If location isn’t provided, the framework will call
the get_absolute_url() method on each object as returned by
items().

To specify a protocol other than 'http', use
protocol.

lastmod

Optional. Either a method or attribute.

If it’s a method, it should take one argument — an object as returned
by items() — and return that object’s last-modified
date/time as a datetime.

If it’s an attribute, its value should be a datetime
representing the last-modified date/time for every object returned by
items().

If all items in a sitemap have a lastmod, the sitemap
generated by views.sitemap() will have a Last-Modified
header equal to the latest lastmod. You can activate the
ConditionalGetMiddleware to make
Django respond appropriately to requests with an If-Modified-Since
header which will prevent sending the sitemap if it hasn’t changed.

changefreq

Optional. Either a method or attribute.

If it’s a method, it should take one argument — an object as returned
by items() — and return that object’s change
frequency as a string.

If it’s an attribute, its value should be a string representing the
change frequency of every object returned by items().

Possible values for changefreq, whether you use a
method or attribute, are:

  • 'always'
  • 'hourly'
  • 'daily'
  • 'weekly'
  • 'monthly'
  • 'yearly'
  • 'never'
priority

Optional. Either a method or attribute.

If it’s a method, it should take one argument — an object as returned
by items() — and return that object’s priority as
either a string or float.

If it’s an attribute, its value should be either a string or float
representing the priority of every object returned by
items().

Example values for priority: 0.4, 1.0. The
default priority of a page is 0.5. See the sitemaps.org
documentation
for more.

protocol

Optional.

This attribute defines the protocol ('http' or 'https') of the
URLs in the sitemap. If it isn’t set, the protocol with which the
sitemap was requested is used. If the sitemap is built outside the
context of a request, the default is 'http'.

limit

Optional.

This attribute defines the maximum number of URLs included on each page
of the sitemap. Its value should not exceed the default value of
50000, which is the upper limit allowed in the Sitemaps protocol.

i18n

Optional.

A boolean attribute that defines if the URLs of this sitemap should
be generated using all of your LANGUAGES. The default is
False.

Shortcuts¶

The sitemap framework provides a convenience class for a common case:

class GenericSitemap(info_dict, priority=None, changefreq=None, protocol=None)[source]

The django.contrib.sitemaps.GenericSitemap class allows you to
create a sitemap by passing it a dictionary which has to contain at least
a queryset entry. This queryset will be used to generate the items
of the sitemap. It may also have a date_field entry that
specifies a date field for objects retrieved from the queryset.
This will be used for the lastmod attribute in the
generated sitemap.

The priority, changefreq,
and protocol keyword arguments allow specifying these
attributes for all URLs.

New in Django 2.0:

The protocol keyword argument was added.

Example¶

Here’s an example of a URLconf using
GenericSitemap:

from django.contrib.sitemaps import GenericSitemap
from django.contrib.sitemaps.views import sitemap
from django.urls import path
from blog.models import Entry

info_dict = {
    'queryset': Entry.objects.all(),
    'date_field': 'pub_date',
}

urlpatterns = [
    # some generic view using info_dict
    # ...

    # the sitemap
    path('sitemap.xml', sitemap,
         {'sitemaps': {'blog': GenericSitemap(info_dict, priority=0.6)}},
         name='django.contrib.sitemaps.views.sitemap'),
]

Sitemap for static views¶

Often you want the search engine crawlers to index views which are neither
object detail pages nor flatpages. The solution is to explicitly list URL
names for these views in items and call reverse() in
the location method of the sitemap. For example:

# sitemaps.py
from django.contrib import sitemaps
from django.urls import reverse

class StaticViewSitemap(sitemaps.Sitemap):
    priority = 0.5
    changefreq = 'daily'

    def items(self):
        return ['main', 'about', 'license']

    def location(self, item):
        return reverse(item)

# urls.py
from django.contrib.sitemaps.views import sitemap
from django.urls import path

from .sitemaps import StaticViewSitemap
from . import views

sitemaps = {
    'static': StaticViewSitemap,
}

urlpatterns = [
    path('', views.main, name='main'),
    path('about/', views.about, name='about'),
    path('license/', views.license, name='license'),
    # ...
    path('sitemap.xml', sitemap, {'sitemaps': sitemaps},
         name='django.contrib.sitemaps.views.sitemap')
]

Creating a sitemap index¶

views.index(request, sitemaps, template_name=’sitemap_index.xml’, content_type=’application/xml’, sitemap_url_name=’django.contrib.sitemaps.views.sitemap’)

The sitemap framework also has the ability to create a sitemap index that
references individual sitemap files, one per each section defined in your
sitemaps dictionary. The only differences in usage are:

Here’s what the relevant URLconf lines would look like for the example above:

from django.contrib.sitemaps import views

urlpatterns = [
    path('sitemap.xml', views.index, {'sitemaps': sitemaps}),
    path('sitemap-<section>.xml', views.sitemap, {'sitemaps': sitemaps},
         name='django.contrib.sitemaps.views.sitemap'),
]

This will automatically generate a sitemap.xml file that references
both sitemap-flatpages.xml and sitemap-blog.xml. The
Sitemap classes and the sitemaps
dict don’t change at all.

You should create an index file if one of your sitemaps has more than 50,000
URLs. In this case, Django will automatically paginate the sitemap, and the
index will reflect that.

If you’re not using the vanilla sitemap view — for example, if it’s wrapped
with a caching decorator — you must name your sitemap view and pass
sitemap_url_name to the index view:

from django.contrib.sitemaps import views as sitemaps_views
from django.views.decorators.cache import cache_page

urlpatterns = [
    path('sitemap.xml',
         cache_page(86400)(sitemaps_views.index),
         {'sitemaps': sitemaps, 'sitemap_url_name': 'sitemaps'}),
    path('sitemap-<section>.xml',
         cache_page(86400)(sitemaps_views.sitemap),
         {'sitemaps': sitemaps}, name='sitemaps'),
]

Template customization¶

If you wish to use a different template for each sitemap or sitemap index
available on your site, you may specify it by passing a template_name
parameter to the sitemap and index views via the URLconf:

from django.contrib.sitemaps import views

urlpatterns = [
    path('custom-sitemap.xml', views.index, {
        'sitemaps': sitemaps,
        'template_name': 'custom_sitemap.html'
    }),
    path('custom-sitemap-<section>.xml', views.sitemap, {
        'sitemaps': sitemaps,
        'template_name': 'custom_sitemap.html'
    }, name='django.contrib.sitemaps.views.sitemap'),
]

These views return TemplateResponse
instances which allow you to easily customize the response data before
rendering. For more details, see the TemplateResponse documentation.

Context variables¶

When customizing the templates for the
index() and
sitemap() views, you can rely on the
following context variables.

Index¶

The variable sitemaps is a list of absolute URLs to each of the sitemaps.

Sitemap¶

The variable urlset is a list of URLs that should appear in the
sitemap. Each URL exposes attributes as defined in the
Sitemap class:

  • changefreq
  • item
  • lastmod
  • location
  • priority

The item attribute has been added for each URL to allow more flexible
customization of the templates, such as Google news sitemaps. Assuming
Sitemap’s items() would return a list of items with
publication_data and a tags field something like this would
generate a Google News compatible sitemap:

<?xml version="1.0" encoding="UTF-8"?>
<urlset
  xmlns="https://www.sitemaps.org/schemas/sitemap/0.9"
  xmlns:news="http://www.google.com/schemas/sitemap-news/0.9">
{% spaceless %}
{% for url in urlset %}
  <url>
    <loc>{{ url.location }}</loc>
    {% if url.lastmod %}<lastmod>{{ url.lastmod|date:"Y-m-d" }}</lastmod>{% endif %}
    {% if url.changefreq %}<changefreq>{{ url.changefreq }}</changefreq>{% endif %}
    {% if url.priority %}<priority>{{ url.priority }}</priority>{% endif %}
    <news:news>
      {% if url.item.publication_date %}<news:publication_date>{{ url.item.publication_date|date:"Y-m-d" }}</news:publication_date>{% endif %}
      {% if url.item.tags %}<news:keywords>{{ url.item.tags }}</news:keywords>{% endif %}
    </news:news>
   </url>
{% endfor %}
{% endspaceless %}
</urlset>

Pinging Google¶

You may want to “ping” Google when your sitemap changes, to let it know to
reindex your site. The sitemaps framework provides a function to do just
that: django.contrib.sitemaps.ping_google().

ping_google()[source]

ping_google() takes an optional argument, sitemap_url,
which should be the absolute path to your site’s sitemap (e.g.,
'/sitemap.xml'). If this argument isn’t provided,
ping_google() will attempt to figure out your
sitemap by performing a reverse looking in your URLconf.

ping_google() raises the exception
django.contrib.sitemaps.SitemapNotFound if it cannot determine your
sitemap URL.

Register with Google first!

The ping_google() command only works if you have registered your
site with Google Webmaster Tools.

One useful way to call ping_google() is from a model’s save()
method:

from django.contrib.sitemaps import ping_google

class Entry(models.Model):
    # ...
    def save(self, force_insert=False, force_update=False):
        super().save(force_insert, force_update)
        try:
            ping_google()
        except Exception:
            # Bare 'except' because we could get a variety
            # of HTTP-related exceptions.
            pass

A more efficient solution, however, would be to call ping_google() from a
cron script, or some other scheduled task. The function makes an HTTP request
to Google’s servers, so you may not want to introduce that network overhead
each time you call save().

Pinging Google via manage.py¶

django-admin ping_google [sitemap_url]

Once the sitemaps application is added to your project, you may also
ping Google using the ping_google management command:

python manage.py ping_google [/sitemap.xml]