Django 1.11 documentation

Home | Table of contents | Index | Modules

up | next »

Django documentation contents

• Getting started
  • Django at a glance
    • Design your model
    • Install it
    • Enjoy the free API
    • A dynamic admin interface: it’s not just scaffolding – it’s the whole house
    • Design your URLs
    • Write your views
    • Design your templates
    • This is just the surface
  • Quick install guide
    • Install Python
    • Set up a database
    • Remove any old versions of Django
    • Install Django
    • Verifying
    • That’s it!
  • Writing your first Django app, part 1
    • Creating a project
    • The development server
    • Creating the Polls app
    • Write your first view
      • url() argument: regex
      • url() argument: view
      • url() argument: kwargs
      • url() argument: name
  • Writing your first Django app, part 2
    • Database setup
    • Creating models
    • Activating models
    • Playing with the API
    • Introducing the Django Admin
      • Creating an admin user
      • Start the development server
      • Enter the admin site
      • Make the poll app modifiable in the admin
      • Explore the free admin functionality
  • Writing your first Django app, part 3
    • Overview
    • Writing more views
    • Write views that actually do something
      • A shortcut: render()
    • Raising a 404 error
      • A shortcut: get_object_or_404()
    • Use the template system
    • Removing hardcoded URLs in templates
    • Namespacing URL names
  • Writing your first Django app, part 4
    • Write a simple form
    • Use generic views: Less code is better
      • Amend URLconf
      • Amend views
  • Writing your first Django app, part 5
    • Introducing automated testing
      • What are automated tests?
      • Why you need to create tests
    • Basic testing strategies
    • Writing our first test
      • We identify a bug
      • Create a test to expose the bug
      • Running tests
      • Fixing the bug
      • More comprehensive tests
    • Test a view
      • A test for a view
      • The Django test client
      • Improving our view
      • Testing our new view
      • Testing the DetailView
      • Ideas for more tests
    • When testing, more is better
    • Further testing
    • What’s next?
  • Writing your first Django app, part 6
    • Customize your app’s look and feel
    • Adding a background-image
  • Writing your first Django app, part 7
    • Customize the admin form
    • Adding related objects
    • Customize the admin change list
    • Customize the admin look and feel
      • Customizing your project’s templates
      • Customizing your application’s templates
    • Customize the admin index page
    • What’s next?
  • Advanced tutorial: How to write reusable apps
    • Reusability matters
    • Your project and your reusable app
    • Installing some prerequisites
    • Packaging your app
    • Using your own package
    • Publishing your app
    • Installing Python packages with virtualenv
  • What to read next
    • Finding documentation
    • How the documentation is organized
    • How documentation is updated
    • Where to get it
      • On the Web
      • In plain text
      • As HTML, locally
    • Differences between versions
  • Writing your first patch for Django
    • Introduction
      • Who’s this tutorial for?
      • What does this tutorial cover?
    • Code of Conduct
    • Installing Git
    • Getting a copy of Django’s development version
    • Rolling back to a previous revision of Django
    • Running Django’s test suite for the first time
    • Writing some tests for your ticket
      • Writing some tests for ticket #24788
      • Running your new test
    • Writing the code for your ticket
      • Writing the code for ticket #24788
      • Verifying your test now passes
    • Running Django’s test suite for the second time
    • Writing Documentation
    • Generating a patch for your changes
    • So what do I do next?
      • More information for new contributors
      • Finding your first real ticket
      • What’s next?
• Using Django
  • How to install Django
    • Install Python
    • Install Apache and mod_wsgi
    • Get your database running
    • Remove any old versions of Django
    • Install the Django code
      • Installing an official release with pip
      • Installing a distribution-specific package
      • Installing the development version
  • Models and databases
    • Models
      • Quick example
      • Using models
      • Fields
      • Meta options
      • Model attributes
      • Model methods
      • Model inheritance
      • Organizing models in a package
    • Making queries
      • Creating objects
      • Saving changes to objects
      • Retrieving objects
      • Complex lookups with Q objects
      • Comparing objects
      • Deleting objects
      • Copying model instances
      • Updating multiple objects at once
      • Related objects
      • Falling back to raw SQL
    • Aggregation
      • Cheat sheet
      • Generating aggregates over a QuerySet
      • Generating aggregates for each item in a QuerySet
      • Joins and aggregates
      • Aggregations and other QuerySet clauses
    • Search
      • Use Cases
    • Managers
      • Manager names
      • Custom managers
    • Performing raw SQL queries
      • Performing raw queries
      • Executing custom SQL directly
    • Database transactions
      • Managing database transactions
      • Autocommit
      • Performing actions after commit
      • Low-level APIs
      • Database-specific notes
    • Multiple databases
      • Defining your databases
      • Synchronizing your databases
      • Automatic database routing
      • Manually selecting a database
      • Exposing multiple databases in Django’s admin interface
      • Using raw cursors with multiple databases
      • Limitations of multiple databases
    • Tablespaces
      • Declaring tablespaces for tables
      • Declaring tablespaces for indexes
      • An example
      • Database support
    • Database access optimization
      • Profile first
      • Use standard DB optimization techniques
      • Understand QuerySets
      • Do database work in the database rather than in Python
      • Retrieve individual objects using a unique, indexed column
      • Retrieve everything at once if you know you will need it
      • Don’t retrieve things you don’t need
      • Insert in bulk
    • Examples of model relationship API usage
      • Many-to-many relationships
      • Many-to-one relationships
      • One-to-one relationships
  • Handling HTTP requests
    • URL dispatcher
      • Overview
      • How Django processes a request
      • Example
      • Named groups
      • What the URLconf searches against
      • Captured arguments are always strings
      • Specifying defaults for view arguments
      • Performance
      • Syntax of the urlpatterns variable
      • Error handling
      • Including other URLconfs
      • Nested arguments
      • Passing extra options to view functions
      • Reverse resolution of URLs
      • Naming URL patterns
      • URL namespaces
    • Writing views
      • A simple view
      • Mapping URLs to views
      • Returning errors
      • Customizing error views
    • View decorators
      • Allowed HTTP methods
      • Conditional view processing
      • GZip compression
      • Vary headers
      • Caching
    • File Uploads
      • Basic file uploads
      • Upload Handlers
    • Django shortcut functions
      • render()
      • render_to_response()
      • redirect()
      • get_object_or_404()
      • get_list_or_404()
    • Generic views
    • Middleware
      • Writing your own middleware
      • Activating middleware
      • Middleware order and layering
      • Other middleware hooks
      • Dealing with streaming responses
      • Exception handling
      • Upgrading pre-Django 1.10-style middleware
    • How to use sessions
      • Enabling sessions
      • Configuring the session engine
      • Using sessions in views
      • Setting test cookies
      • Using sessions out of views
      • When sessions are saved
      • Browser-length sessions vs. persistent sessions
      • Clearing the session store
      • Settings
      • Session security
      • Technical details
      • Extending database-backed session engines
      • Session IDs in URLs
  • Working with forms
    • HTML forms
      • GET and POST
    • Django’s role in forms
    • Forms in Django
      • The Django Form class
      • Instantiating, processing, and rendering forms
    • Building a form
      • The work that needs to be done
      • Building a form in Django
    • More about Django Form classes
      • Bound and unbound form instances
      • More on fields
    • Working with form templates
      • Form rendering options
      • Rendering fields manually
      • Looping over the form’s fields
      • Reusable form templates
    • Further topics
      • Formsets
      • Creating forms from models
      • Form Assets (the Media class)
  • Templates
    • Support for template engines
      • Configuration
      • Usage
      • Built-in backends
      • Custom backends
      • Debug integration for custom engines
    • The Django template language
      • Syntax
      • Components
  • Class-based views
    • Introduction to class-based views
      • The relationship and history of generic views, class-based views, and class-based generic views
      • Using class-based views
      • Using mixins
      • Handling forms with class-based views
      • Decorating class-based views
    • Built-in class-based generic views
      • Extending generic views
      • Generic views of objects
    • Form handling with class-based views
      • Basic forms
      • Model forms
      • Models and request.user
      • AJAX example
    • Using mixins with class-based views
      • Context and template responses
      • Building up Django’s generic class-based views
      • Using Django’s class-based view mixins
      • Avoid anything more complex
      • More than just HTML
    • Basic examples
    • Simple usage in your URLconf
    • Subclassing generic views
      • Supporting other HTTP methods
  • Migrations
    • The Commands
    • Backend Support
      • PostgreSQL
      • MySQL
      • SQLite
    • Workflow
      • Version control
    • Dependencies
    • Migration files
      • Custom fields
      • Model managers
      • Initial migrations
    • Adding migrations to apps
    • Historical models
    • Considerations when removing model fields
    • Data Migrations
      • Accessing models from other apps
      • More advanced migrations
    • Squashing migrations
    • Serializing values
      • Adding a deconstruct() method
    • Supporting Python 2 and 3
    • Supporting multiple Django versions
  • Managing files
    • Using files in models
    • The File object
    • File storage
      • Storage objects
      • The built-in filesystem storage class
  • Testing in Django
    • Writing and running tests
      • Writing tests
      • Running tests
    • Testing tools
      • The test client
      • Provided test case classes
      • Test cases features
      • Email services
      • Management Commands
      • Skipping tests
    • Advanced testing topics
      • The request factory
      • Tests and multiple host names
      • Tests and multiple databases
      • Advanced features of TransactionTestCase
      • Using the Django test runner to test reusable applications
      • Using different testing frameworks
      • Integration with coverage.py
  • User authentication in Django
    • Overview
    • Installation
    • Usage
  • Django’s cache framework
    • Setting up the cache
      • Memcached
      • Database caching
      • Filesystem caching
      • Local-memory caching
      • Dummy caching (for development)
      • Using a custom cache backend
      • Cache arguments
    • The per-site cache
    • The per-view cache
      • Specifying per-view cache in the URLconf
    • Template fragment caching
    • The low-level cache API
      • Accessing the cache
      • Basic usage
      • Cache key prefixing
      • Cache versioning
      • Cache key transformation
      • Cache key warnings
    • Downstream caches
    • Using Vary headers
    • Controlling cache: Using other headers
    • Order of MIDDLEWARE
  • Conditional View Processing
    • The condition decorator
    • Shortcuts for only computing one value
      • Use condition when testing both conditions
    • Using the decorators with other HTTP methods
    • Comparison with middleware conditional processing
  • Cryptographic signing
    • Protecting the SECRET_KEY
    • Using the low-level API
      • Using the salt argument
      • Verifying timestamped values
      • Protecting complex data structures
  • Sending email
    • Quick example
    • send_mail()
    • send_mass_mail()
      • send_mass_mail() vs. send_mail()
    • mail_admins()
    • mail_managers()
    • Examples
    • Preventing header injection
    • The EmailMessage class
      • EmailMessage Objects
    • Email backends
      • Obtaining an instance of an email backend
      • Defining a custom email backend
      • Sending multiple emails
    • Configuring email for development
  • Internationalization and localization
    • Overview
    • Definitions
  • Logging
    • A quick logging primer
      • The cast of players
    • Using logging
      • Naming loggers
      • Making logging calls
    • Configuring logging
      • Examples
      • Custom logging configuration
      • Disabling logging configuration
    • Django’s logging extensions
      • Loggers
      • Handlers
      • Filters
    • Django’s default logging configuration
  • Pagination
    • Example
    • Using Paginator in a view
    • Paginator objects
      • Required arguments
      • Optional arguments
      • Methods
      • Attributes
    • InvalidPage exceptions
    • Page objects
      • Methods
      • Attributes
  • Porting to Python 3
    • Philosophy
    • Porting tips
      • Unicode literals
      • String handling
      • __str__() and __unicode__() methods
      • dict and dict-like classes
      • HttpRequest and HttpResponse objects
    • Coding guidelines
      • Syntax requirements
      • Magic methods
      • Writing compatible code with six
      • Django customized version of six
  • Security in Django
    • Cross site scripting (XSS) protection
    • Cross site request forgery (CSRF) protection
    • SQL injection protection
    • Clickjacking protection
    • SSL/HTTPS
    • Host header validation
    • Session security
    • User-uploaded content
    • Additional security topics
  • Performance and optimization
    • Introduction
    • General approaches
      • What are you optimizing for?
      • Performance benchmarking
      • Get things right from the start
    • Caching
      • The caching framework
      • cached_property
    • Understanding laziness
      • Laziness in Django
    • Databases
      • Database optimization
      • Other database-related tips
    • HTTP performance
      • Middleware
      • Sessions
      • Static files
    • Template performance
      • The cached template loader
    • Using different versions of available software
      • Newer is often - but not always - better
      • Alternatives to Django’s template language
      • Alternative software implementations
  • Serializing Django objects
    • Serializing data
      • Subset of fields
      • Inherited models
    • Deserializing data
    • Serialization formats
      • XML
      • JSON
      • YAML
    • Natural keys
      • Deserialization of natural keys
      • Serialization of natural keys
      • Dependencies during serialization
  • Django settings
    • The basics
    • Designating the settings
      • The django-admin utility
      • On the server (mod_wsgi)
    • Default settings
      • Seeing which settings you’ve changed
    • Using settings in Python code
    • Altering settings at runtime
    • Security
    • Available settings
    • Creating your own settings
    • Using settings without setting DJANGO_SETTINGS_MODULE
      • Custom default settings
      • Either configure() or DJANGO_SETTINGS_MODULE is required
      • Calling django.setup() is required for “standalone” Django usage
  • Signals
    • Listening to signals
      • Receiver functions
      • Connecting receiver functions
      • Connecting to signals sent by specific senders
      • Preventing duplicate signals
    • Defining and sending signals
      • Defining signals
      • Sending signals
    • Disconnecting signals
  • System check framework
    • Writing your own checks
      • Messages
      • Registering and labeling checks
      • Field, model, manager, and database checks
      • Writing tests
  • External packages
    • Localflavor
    • Comments
    • Formtools
• “How-to” guides
  • Authentication using REMOTE_USER
    • Configuration
    • Using REMOTE_USER on login pages only
  • Writing custom django-admin commands
    • Accepting optional arguments
    • Management commands and locales
    • Testing
    • Command objects
      • Attributes
      • Methods
      • BaseCommand subclasses
      • Command exceptions
  • Writing custom model fields
    • Introduction
      • Our example object
    • Background theory
      • Database storage
      • What does a field class do?
    • Writing a field subclass
      • Field deconstruction
      • Changing a custom field’s base class
      • Documenting your custom field
      • Useful methods
      • Some general advice
    • Writing a FileField subclass
      • A few suggestions
  • Custom Lookups
    • A simple lookup example
    • A simple transformer example
    • Writing an efficient abs__lt lookup
    • A bilateral transformer example
    • Writing alternative implementations for existing lookups
    • How Django determines the lookups and transforms which are used
  • Custom template tags and filters
    • Code layout
    • Writing custom template filters
      • Registering custom filters
      • Template filters that expect strings
      • Filters and auto-escaping
      • Filters and time zones
    • Writing custom template tags
      • Simple tags
      • Inclusion tags
      • Assignment tags
      • Advanced custom template tags
      • A quick overview
      • Writing the compilation function
      • Writing the renderer
      • Auto-escaping considerations
      • Thread-safety considerations
      • Registering the tag
      • Passing template variables to the tag
      • Setting a variable in the context
      • Parsing until another block tag
      • Parsing until another block tag, and saving contents
  • Writing a custom storage system
  • Deploying Django
    • How to deploy with WSGI
      • How to use Django with Apache and mod_wsgi
      • Authenticating against Django’s user database from Apache
      • How to use Django with Gunicorn
      • How to use Django with uWSGI
      • The application object
      • Configuring the settings module
      • Applying WSGI middleware
    • Deployment checklist
      • Run manage.py check --deploy
      • Critical settings
      • Environment-specific settings
      • HTTPS
      • Performance optimizations
      • Error reporting
      • Python Options
  • Upgrading Django to a newer version
    • Required Reading
    • Dependencies
    • Resolving deprecation warnings
    • Installation
    • Testing
    • Deployment
  • Error reporting
    • Email reports
      • Server errors
      • 404 errors
    • Filtering error reports
      • Filtering sensitive information
      • Custom error reports
  • Providing initial data for models
    • Providing initial data with fixtures
      • Where Django finds fixture files
  • Running Django on Jython
    • Installing Jython
    • Creating a servlet container
    • Installing Django
    • Installing Jython platform support libraries
    • Differences with Django on Jython
  • Integrating Django with a legacy database
    • Give Django your database parameters
    • Auto-generate the models
    • Install the core Django tables
    • Test and tweak
  • Outputting CSV with Django
    • Using the Python CSV library
      • Streaming large CSV files
    • Using the template system
    • Other text-based formats
  • Outputting PDFs with Django
    • Install ReportLab
    • Write your view
    • Complex PDFs
    • Further resources
    • Other formats
  • Managing static files (e.g. images, JavaScript, CSS)
    • Configuring static files
    • Serving static files during development
    • Serving files uploaded by a user during development
    • Testing
    • Deployment
    • Learn more
  • Deploying static files
    • Serving static files in production
      • Serving the site and your static files from the same server
      • Serving static files from a dedicated server
      • Serving static files from a cloud service or CDN
    • Learn more
  • How to install Django on Windows
    • Install Python
    • About pip
    • Install virtualenv and virtualenvwrapper
    • Install Django
    • Common pitfalls
  • Writing database migrations
    • Data migrations and multiple databases
    • Migrations that add unique fields
      • Non-atomic migrations
    • Controlling the order of migrations
    • Migrating data between third-party apps
    • Changing an unmanaged model to managed
• Django FAQ
  • FAQ: General
    • Why does this project exist?
    • What does “Django” mean, and how do you pronounce it?
    • Is Django stable?
    • Does Django scale?
    • Who’s behind this?
    • Which sites use Django?
    • Django appears to be a MVC framework, but you call the Controller the “view”, and the View the “template”. How come you don’t use the standard names?
    • <Framework X> does <feature Y> – why doesn’t Django?
    • Why did you write all of Django from scratch, instead of using other Python libraries?
    • Is Django a content-management-system (CMS)?
    • How can I download the Django documentation to read it offline?
    • Where can I find Django developers for hire?
    • How do I cite Django?
  • FAQ: Installation
    • How do I get started?
    • What are Django’s prerequisites?
    • What Python version can I use with Django?
    • What Python version should I use with Django?
    • Should I use the stable version or development version?
  • FAQ: Using Django
    • Why do I get an error about importing DJANGO_SETTINGS_MODULE?
    • I can’t stand your template language. Do I have to use it?
    • Do I have to use your model/database layer?
    • How do I use image and file fields?
    • How do I make a variable available to all my templates?
  • FAQ: Getting Help
    • How do I do X? Why doesn’t Y work? Where can I go to get help?
    • Why hasn’t my message appeared on django-users?
    • Nobody on django-users answered my question! What should I do?
    • I think I’ve found a bug! What should I do?
    • I think I’ve found a security problem! What should I do?
  • FAQ: Databases and models
    • How can I see the raw SQL queries Django is running?
    • Can I use Django with a pre-existing database?
    • If I make changes to a model, how do I update the database?
    • Do Django models support multiple-column primary keys?
    • Does Django support NoSQL databases?
    • How do I add database-specific options to my CREATE TABLE statements, such as specifying MyISAM as the table type?
  • FAQ: The admin
    • I can’t log in. When I enter a valid username and password, it just brings up the login page again, with no error messages.
    • I can’t log in. When I enter a valid username and password, it brings up the login page again, with a “Please enter a correct username and password” error.
    • How do I automatically set a field’s value to the user who last edited the object in the admin?
    • How do I limit admin access so that objects can only be edited by the users who created them?
    • My admin-site CSS and images showed up fine using the development server, but they’re not displaying when using mod_wsgi.
    • My “list_filter” contains a ManyToManyField, but the filter doesn’t display.
    • Some objects aren’t appearing in the admin.
    • How can I customize the functionality of the admin interface?
    • The dynamically-generated admin site is ugly! How can I change it?
    • What browsers are supported for using the admin?
  • FAQ: Contributing code
    • How can I get started contributing code to Django?
    • I submitted a bug fix in the ticket system several weeks ago. Why are you ignoring my patch?
    • When and how might I remind the core team of a patch I care about?
    • But I’ve reminded you several times and you keep ignoring my patch!
  • Troubleshooting
    • Problems running django-admin
      • “command not found: django-admin”
      • Mac OS X permissions
    • Miscellaneous
      • I’m getting a UnicodeDecodeError. What am I doing wrong?
• API Reference
  • Applications
    • Projects and applications
    • Configuring applications
      • For application authors
      • For application users
    • Application configuration
      • Configurable attributes
      • Read-only attributes
      • Methods
      • Namespace packages as apps (Python 3.3+)
    • Application registry
    • Initialization process
      • How applications are loaded
      • Troubleshooting
  • System check framework
    • API Reference
      • CheckMessage
    • Builtin checks
      • Builtin tags
      • Core system checks
      • Admin
      • Auth
      • Content Types
      • Security
      • Sites
      • Database
      • Templates
      • Caches
      • URLs
  • Built-in class-based views API
    • Base views
      • View
      • TemplateView
      • RedirectView
    • Generic display views
      • DetailView
      • ListView
    • Generic editing views
      • FormView
      • CreateView
      • UpdateView
      • DeleteView
    • Generic date views
      • ArchiveIndexView
      • YearArchiveView
      • MonthArchiveView
      • WeekArchiveView
      • DayArchiveView
      • TodayArchiveView
      • DateDetailView
    • Class-based views mixins
      • Simple mixins
      • Single object mixins
      • Multiple object mixins
      • Editing mixins
      • Date-based mixins
    • Class-based generic views - flattened index
      • Simple generic views
      • Detail Views
      • List Views
      • Editing views
      • Date-based views
    • Specification
    • Base vs Generic views
  • Clickjacking Protection
    • An example of clickjacking
    • Preventing clickjacking
    • How to use it
      • Setting X-Frame-Options for all responses
      • Setting X-Frame-Options per view
    • Limitations
      • Browsers that support X-Frame-Options
      • See also
  • contrib packages
    • The Django admin site
      • Overview
      • ModelAdmin objects
      • InlineModelAdmin objects
      • Overriding admin templates
      • AdminSite objects
      • LogEntry objects
      • Reversing admin URLs
      • The staff_member_required decorator
    • django.contrib.auth
      • User model
      • AnonymousUser object
      • Permission model
      • Group model
      • Validators
      • Login and logout signals
      • Authentication backends
    • The contenttypes framework
      • Overview
      • Installing the contenttypes framework
      • The ContentType model
      • Methods on ContentType instances
      • Generic relations
    • The flatpages app
      • Installation
      • How it works
      • How to add, change and delete flatpages
      • Flatpage templates
      • Getting a list of FlatPage objects in your templates
      • Integrating with django.contrib.sitemaps
    • GeoDjango
      • GeoDjango Tutorial
      • GeoDjango Installation
      • GeoDjango Model API
      • GeoDjango Database API
      • GeoDjango Forms API
      • GeoQuerySet API Reference
      • Geographic Database Functions
      • Measurement Objects
      • GEOS API
      • GDAL API
      • Geolocation with GeoIP
      • Geolocation with GeoIP2
      • GeoDjango Utilities
      • GeoDjango Management Commands
      • GeoDjango’s admin site
      • Geographic Feeds
      • Geographic Sitemaps
      • Testing GeoDjango apps
      • Deploying GeoDjango
    • django.contrib.humanize
      • apnumber
      • intcomma
      • intword
      • naturalday
      • naturaltime
      • ordinal
    • The messages framework
      • Enabling messages
      • Configuring the message engine
      • Using messages in views and templates
      • Expiration of messages
      • Behavior of parallel requests
      • Settings
    • django.contrib.postgres
      • PostgreSQL specific aggregation functions
      • PostgreSQL specific model fields
      • PostgreSQL specific form fields and widgets
      • PostgreSQL specific database functions
      • PostgreSQL specific model indexes
      • PostgreSQL specific lookups
      • Database migration operations
      • Full text search
      • Validators
    • The redirects app
      • Installation
      • How it works
      • How to add, change and delete redirects
      • Middleware
    • The sitemap framework
      • Overview
      • Installation
      • Initialization
      • Sitemap classes
      • A simple example
      • Sitemap class reference
      • Shortcuts
      • Sitemap for static views
      • Creating a sitemap index
      • Template customization
      • Pinging Google
    • The “sites” framework
      • Example usage
      • Enabling the sites framework
      • Caching the current Site object
      • The CurrentSiteManager
      • Site middleware
      • How Django uses the sites framework
      • RequestSite objects
      • get_current_site shortcut
    • The staticfiles app
      • Settings
      • Management Commands
      • Storages
      • Finders Module
      • Other Helpers
    • The syndication feed framework
      • The high-level framework
      • The low-level framework
    • admin
    • auth
    • contenttypes
    • flatpages
    • gis
    • humanize
    • messages
    • postgres
    • redirects
    • sessions
    • sites
    • sitemaps
    • syndication
    • Other add-ons
  • Cross Site Request Forgery protection
    • How to use it
      • AJAX
      • Using CSRF in Jinja2 templates
      • The decorator method
    • Rejected requests
    • How it works
    • Caching
    • Testing
    • Limitations
    • Edge cases
      • Utilities
      • Scenarios
    • Contrib and reusable apps
    • Settings
    • Frequently Asked Questions
      • Is posting an arbitrary CSRF token pair (cookie and POST data) a vulnerability?
      • Is the fact that Django’s CSRF protection isn’t linked to a session a problem?
      • Why might a user encounter a CSRF validation failure after logging in?
  • Databases
    • General notes
      • Persistent connections
      • Encoding
    • PostgreSQL notes
      • PostgreSQL connection settings
      • Optimizing PostgreSQL’s configuration
      • Isolation level
      • Indexes for varchar and text columns
      • Test database templates
      • Speeding up test execution with non-durable settings
    • MySQL notes
      • Version support
      • Storage engines
      • MySQL DB API Drivers
      • Time zone definitions
      • Creating your database
      • Connecting to the database
      • Creating your tables
      • Table names
      • Savepoints
      • Notes on specific fields
      • Row locking with QuerySet.select_for_update()
      • Automatic typecasting can cause unexpected results
    • SQLite notes
      • Substring matching and case sensitivity
      • Old SQLite and CASE expressions
      • Using newer versions of the SQLite DB-API 2.0 driver
      • “Database is locked” errors
      • QuerySet.select_for_update() not supported
      • “pyformat” parameter style in raw queries not supported
    • Oracle notes
      • Connecting to the database
      • Threaded option
      • INSERT ... RETURNING INTO
      • Naming issues
      • NULL and empty strings
      • TextField limitations
    • Using a 3rd-party database backend
  • django-admin and manage.py
    • Usage
      • Getting runtime help
      • App names
      • Determining the version
      • Displaying debug output
    • Available commands
      • check
      • compilemessages
      • createcachetable
      • dbshell
      • diffsettings
      • dumpdata
      • flush
      • inspectdb
      • loaddata
      • makemessages
      • makemigrations
      • migrate
      • runserver
      • sendtestemail
      • shell
      • showmigrations
      • sqlflush
      • sqlmigrate
      • sqlsequencereset
      • squashmigrations
      • startapp
      • startproject
      • test
      • testserver
    • Commands provided by applications
      • django.contrib.auth
      • django.contrib.gis
      • django.contrib.sessions
      • django.contrib.sitemaps
      • django.contrib.staticfiles
    • Default options
    • Extra niceties
      • Syntax coloring
      • Bash completion
  • Running management commands from your code
    • Output redirection
  • Django Exceptions
    • Django Core Exceptions
      • ObjectDoesNotExist
      • EmptyResultSet
      • FieldDoesNotExist
      • MultipleObjectsReturned
      • SuspiciousOperation
      • PermissionDenied
      • ViewDoesNotExist
      • MiddlewareNotUsed
      • ImproperlyConfigured
      • FieldError
      • ValidationError
    • URL Resolver exceptions
      • Resolver404
      • NoReverseMatch
    • Database Exceptions
    • Http Exceptions
      • UnreadablePostError
    • Transaction Exceptions
      • TransactionManagementError
    • Testing Framework Exceptions
      • RedirectCycleError
    • Python Exceptions
  • File handling
    • The File object
      • The File class
      • The ContentFile class
      • The ImageFile class
      • Additional methods on files attached to objects
    • File storage API
      • Getting the current storage class
      • The FileSystemStorage class
      • The Storage class
    • Uploaded Files and Upload Handlers
      • Uploaded files
      • Built-in upload handlers
      • Writing custom upload handlers
  • Forms
    • The Forms API
      • Bound and unbound forms
      • Using forms to validate data
      • Dynamic initial values
      • Checking which form data has changed
      • Accessing the fields from the form
      • Accessing “clean” data
      • Outputting forms as HTML
      • More granular output
      • Customizing BoundField
      • Binding uploaded files to a form
      • Subclassing forms
      • Prefixes for forms
    • Form fields
      • Core field arguments
      • Checking if the field data has changed
      • Built-in Field classes
      • Slightly complex built-in Field classes
      • Fields which handle relationships
      • Creating custom fields
    • Model Form Functions
      • modelform_factory
      • modelformset_factory
      • inlineformset_factory
    • Formset Functions
      • formset_factory
    • Widgets
      • Specifying widgets
      • Setting arguments for widgets
      • Widgets inheriting from the Select widget
      • Customizing widget instances
      • Base widget classes
      • Built-in widgets
    • Form and field validation
      • Raising ValidationError
      • Using validation in practice
  • Middleware
    • Available middleware
      • Cache middleware
      • “Common” middleware
      • Exception middleware
      • GZip middleware
      • Conditional GET middleware
      • Locale middleware
      • Message middleware
      • Security middleware
      • Session middleware
      • Site middleware
      • Authentication middleware
      • CSRF protection middleware
      • X-Frame-Options middleware
    • Middleware ordering
  • Migration Operations
    • Schema Operations
      • CreateModel
      • DeleteModel
      • RenameModel
      • AlterModelTable
      • AlterUniqueTogether
      • AlterIndexTogether
      • AlterOrderWithRespectTo
      • AlterModelOptions
      • AlterModelManagers
      • AddField
      • RemoveField
      • AlterField
      • RenameField
      • AddIndex
      • RemoveIndex
    • Special Operations
      • RunSQL
      • RunPython
      • SeparateDatabaseAndState
    • Writing your own
  • Models
    • Model field reference
      • Field options
      • Field types
      • Relationship fields
      • Field API reference
    • Field attribute reference
      • Attributes for fields
      • Attributes for fields with relations
    • Model index reference
      • Index options
    • Model _meta API
      • Field access API
      • Migrating from the old API
    • Related objects reference
      • Direct Assignment
    • Model class reference
      • Attributes
    • Model Meta options
      • Available Meta options
      • Read-only Meta attributes
    • Model instance reference
      • Creating objects
      • Refreshing objects from database
      • Validating objects
      • Saving objects
      • Deleting objects
      • Pickling objects
      • Other model instance methods
      • Extra instance methods
      • Other attributes
    • QuerySet API reference
      • When QuerySets are evaluated
      • QuerySet API
      • Query-related tools
    • Lookup API reference
      • Registration API
      • The Query Expression API
      • Transform reference
      • Lookup reference
    • Query Expressions
      • Supported arithmetic
      • Some examples
      • Built-in Expressions
      • Technical Information
    • Conditional Expressions
      • The conditional expression classes
      • Advanced queries
    • Database Functions
      • Cast
      • Coalesce
      • Concat
      • Greatest
      • Least
      • Length
      • Lower
      • Now
      • Substr
      • Upper
      • Date Functions
  • Request and response objects
    • Quick overview
    • HttpRequest objects
      • Attributes
      • Attributes set by application code
      • Attributes set by middleware
      • Methods
    • QueryDict objects
      • Methods
    • HttpResponse objects
      • Usage
      • Attributes
      • Methods
      • HttpResponse subclasses
    • JsonResponse objects
      • Usage
    • StreamingHttpResponse objects
      • Attributes
    • FileResponse objects
  • SchemaEditor
    • Methods
      • execute()
      • create_model()
      • delete_model()
      • add_index()
      • remove_index()
      • alter_unique_together()
      • alter_index_together()
      • alter_db_table()
      • alter_db_tablespace()
      • add_field()
      • remove_field()
      • alter_field()
    • Attributes
      • connection
  • Settings
    • Core Settings
      • ABSOLUTE_URL_OVERRIDES
      • ADMINS
      • ALLOWED_HOSTS
      • APPEND_SLASH
      • CACHES
      • CACHE_MIDDLEWARE_ALIAS
      • CACHE_MIDDLEWARE_KEY_PREFIX
      • CACHE_MIDDLEWARE_SECONDS
      • CSRF_COOKIE_AGE
      • CSRF_COOKIE_DOMAIN
      • CSRF_COOKIE_HTTPONLY
      • CSRF_COOKIE_NAME
      • CSRF_COOKIE_PATH
      • CSRF_COOKIE_SECURE
      • CSRF_FAILURE_VIEW
      • CSRF_HEADER_NAME
      • CSRF_TRUSTED_ORIGINS
      • DATABASES
      • DATA_UPLOAD_MAX_MEMORY_SIZE
      • DATA_UPLOAD_MAX_NUMBER_FIELDS
      • DATABASE_ROUTERS
      • DATE_FORMAT
      • DATE_INPUT_FORMATS
      • DATETIME_FORMAT
      • DATETIME_INPUT_FORMATS
      • DEBUG
      • DEBUG_PROPAGATE_EXCEPTIONS
      • DECIMAL_SEPARATOR
      • DEFAULT_CHARSET
      • DEFAULT_CONTENT_TYPE
      • DEFAULT_EXCEPTION_REPORTER_FILTER
      • DEFAULT_FILE_STORAGE
      • DEFAULT_FROM_EMAIL
      • DEFAULT_INDEX_TABLESPACE
      • DEFAULT_TABLESPACE
      • DISALLOWED_USER_AGENTS
      • EMAIL_BACKEND
      • EMAIL_FILE_PATH
      • EMAIL_HOST
      • EMAIL_HOST_PASSWORD
      • EMAIL_HOST_USER
      • EMAIL_PORT
      • EMAIL_SUBJECT_PREFIX
      • EMAIL_USE_LOCALTIME
      • EMAIL_USE_TLS
      • EMAIL_USE_SSL
      • EMAIL_SSL_CERTFILE
      • EMAIL_SSL_KEYFILE
      • EMAIL_TIMEOUT
      • FILE_CHARSET
      • FILE_UPLOAD_HANDLERS
      • FILE_UPLOAD_MAX_MEMORY_SIZE
      • FILE_UPLOAD_DIRECTORY_PERMISSIONS
      • FILE_UPLOAD_PERMISSIONS
      • FILE_UPLOAD_TEMP_DIR
      • FIRST_DAY_OF_WEEK
      • FIXTURE_DIRS
      • FORCE_SCRIPT_NAME
      • FORMAT_MODULE_PATH
      • IGNORABLE_404_URLS
      • INSTALLED_APPS
      • INTERNAL_IPS
      • LANGUAGE_CODE
      • LANGUAGE_COOKIE_AGE
      • LANGUAGE_COOKIE_DOMAIN
      • LANGUAGE_COOKIE_NAME
      • LANGUAGE_COOKIE_PATH
      • LANGUAGES
      • LOCALE_PATHS
      • LOGGING
      • LOGGING_CONFIG
      • MANAGERS
      • MEDIA_ROOT
      • MEDIA_URL
      • MIDDLEWARE
      • MIDDLEWARE_CLASSES
      • MIGRATION_MODULES
      • MONTH_DAY_FORMAT
      • NUMBER_GROUPING
      • PREPEND_WWW
      • ROOT_URLCONF
      • SECRET_KEY
      • SECURE_BROWSER_XSS_FILTER
      • SECURE_CONTENT_TYPE_NOSNIFF
      • SECURE_HSTS_INCLUDE_SUBDOMAINS
      • SECURE_HSTS_PRELOAD
      • SECURE_HSTS_SECONDS
      • SECURE_PROXY_SSL_HEADER
      • SECURE_REDIRECT_EXEMPT
      • SECURE_SSL_HOST
      • SECURE_SSL_REDIRECT
      • SERIALIZATION_MODULES
      • SERVER_EMAIL
      • SHORT_DATE_FORMAT
      • SHORT_DATETIME_FORMAT
      • SIGNING_BACKEND
      • SILENCED_SYSTEM_CHECKS
      • TEMPLATES
      • TEST_RUNNER
      • TEST_NON_SERIALIZED_APPS
      • THOUSAND_SEPARATOR
      • TIME_FORMAT
      • TIME_INPUT_FORMATS
      • TIME_ZONE
      • USE_ETAGS
      • USE_I18N
      • USE_L10N
      • USE_THOUSAND_SEPARATOR
      • USE_TZ
      • USE_X_FORWARDED_HOST
      • USE_X_FORWARDED_PORT
      • WSGI_APPLICATION
      • YEAR_MONTH_FORMAT
      • X_FRAME_OPTIONS
    • Auth
      • AUTHENTICATION_BACKENDS
      • AUTH_USER_MODEL
      • LOGIN_REDIRECT_URL
      • LOGIN_URL
      • LOGOUT_REDIRECT_URL
      • PASSWORD_RESET_TIMEOUT_DAYS
      • PASSWORD_HASHERS
      • AUTH_PASSWORD_VALIDATORS
    • Messages
      • MESSAGE_LEVEL
      • MESSAGE_STORAGE
      • MESSAGE_TAGS
    • Sessions
      • SESSION_CACHE_ALIAS
      • SESSION_COOKIE_AGE
      • SESSION_COOKIE_DOMAIN
      • SESSION_COOKIE_HTTPONLY
      • SESSION_COOKIE_NAME
      • SESSION_COOKIE_PATH
      • SESSION_COOKIE_SECURE
      • SESSION_ENGINE
      • SESSION_EXPIRE_AT_BROWSER_CLOSE
      • SESSION_FILE_PATH
      • SESSION_SAVE_EVERY_REQUEST
      • SESSION_SERIALIZER
    • Sites
      • SITE_ID
    • Static Files
      • STATIC_ROOT
      • STATIC_URL
      • STATICFILES_DIRS
      • STATICFILES_STORAGE
      • STATICFILES_FINDERS
    • Core Settings Topical Index
      • Cache
      • Database
      • Debugging
      • Email
      • Error reporting
      • File uploads
      • Globalization (i18n/l10n)
      • HTTP
      • Logging
      • Models
      • Security
      • Serialization
      • Templates
      • Testing
      • URLs
  • Signals
    • Model signals
      • pre_init
      • post_init
      • pre_save
      • post_save
      • pre_delete
      • post_delete
      • m2m_changed
      • class_prepared
    • Management signals
      • pre_migrate
      • post_migrate
    • Request/response signals
      • request_started
      • request_finished
      • got_request_exception
    • Test signals
      • setting_changed
      • template_rendered
    • Database Wrappers
      • connection_created
  • Templates
    • The Django template language
      • Templates
      • Variables
      • Filters
      • Tags
      • Comments
      • Template inheritance
      • Automatic HTML escaping
      • Accessing method calls
      • Custom tag and filter libraries
    • Built-in template tags and filters
      • Built-in tag reference
      • Built-in filter reference
      • Internationalization tags and filters
      • Other tags and filters libraries
    • The Django template language: for Python programmers
      • Overview
      • Configuring an engine
      • Loading a template
      • Rendering a context
      • Playing with Context objects
      • Loading templates
      • Custom loaders
      • Template origin
    • Upgrading templates to Django 1.8
      • The TEMPLATES settings
      • django.template.loader
      • Template()
  • TemplateResponse and SimpleTemplateResponse
    • SimpleTemplateResponse objects
      • Attributes
      • Methods
    • TemplateResponse objects
      • Methods
    • The rendering process
      • Post-render callbacks
    • Using TemplateResponse and SimpleTemplateResponse
  • Unicode data
    • Creating the database
    • General string handling
      • Translated strings
      • Useful utility functions
    • Models
      • Choosing between __str__() and __unicode__()
      • Taking care in get_absolute_url()
    • The database API
    • Templates
      • Template tags and filters
    • Files
    • Email
    • Form submission
  • django.urls utility functions
    • reverse()
    • reverse_lazy()
    • resolve()
    • get_script_prefix()
  • django.conf.urls utility functions
    • static()
    • url()
    • include()
    • handler400
    • handler403
    • handler404
    • handler500
  • Django Utils
    • django.utils.cache
    • django.utils.dateparse
    • django.utils.decorators
    • django.utils.encoding
    • django.utils.feedgenerator
      • SyndicationFeed
      • Enclosure
      • RssFeed
      • Rss201rev2Feed
      • RssUserland091Feed
      • Atom1Feed
    • django.utils.functional
    • django.utils.html
    • django.utils.http
    • django.utils.module_loading
    • django.utils.safestring
    • django.utils.text
    • django.utils.timezone
    • django.utils.translation
  • Validators
    • Writing validators
    • How validators are run
    • Built-in validators
      • RegexValidator
      • EmailValidator
      • URLValidator
      • validate_email
      • validate_slug
      • validate_unicode_slug
      • validate_ipv4_address
      • validate_ipv6_address
      • validate_ipv46_address
      • validate_comma_separated_integer_list
      • int_list_validator
      • MaxValueValidator
      • MinValueValidator
      • MaxLengthValidator
      • MinLengthValidator
      • DecimalValidator
      • FileExtensionValidator
      • validate_image_file_extension
  • 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
• Meta-documentation and miscellany
  • API stability
    • What “stable” means
    • Stable APIs
    • Exceptions
      • Security fixes
      • APIs marked as internal
  • Design philosophies
    • Overall
      • Loose coupling
      • Less code
      • Quick development
      • Don’t repeat yourself (DRY)
      • Explicit is better than implicit
      • Consistency
    • Models
      • Explicit is better than implicit
      • Include all relevant domain logic
    • Database API
      • SQL efficiency
      • Terse, powerful syntax
      • Option to drop into raw SQL easily, when needed
    • URL design
      • Loose coupling
      • Infinite flexibility
      • Encourage best practices
      • Definitive URLs
    • Template system
      • Separate logic from presentation
      • Discourage redundancy
      • Be decoupled from HTML
      • XML should not be used for template languages
      • Assume designer competence
      • Treat whitespace obviously
      • Don’t invent a programming language
      • Safety and security
      • Extensibility
    • Views
      • Simplicity
      • Use request objects
      • Loose coupling
      • Differentiate between GET and POST
    • Cache Framework
      • Less code
      • Consistency
      • Extensibility
  • Third-party distributions of Django
    • For distributors
• Glossary
• Release notes
  • Final releases
    • 1.11 release
      • Django 1.11 release notes - UNDER DEVELOPMENT
    • 1.10 release
      • Django 1.10.1 release notes
      • Django 1.10 release notes
    • 1.9 release
      • Django 1.9.9 release notes
      • Django 1.9.8 release notes
      • Django 1.9.7 release notes
      • Django 1.9.6 release notes
      • Django 1.9.5 release notes
      • Django 1.9.4 release notes
      • Django 1.9.3 release notes
      • Django 1.9.2 release notes
      • Django 1.9.1 release notes
      • Django 1.9 release notes
    • 1.8 release
      • Django 1.8.14 release notes
      • Django 1.8.13 release notes
      • Django 1.8.12 release notes
      • Django 1.8.11 release notes
      • Django 1.8.10 release notes
      • Django 1.8.9 release notes
      • Django 1.8.8 release notes
      • Django 1.8.7 release notes
      • Django 1.8.6 release notes
      • Django 1.8.5 release notes
      • Django 1.8.4 release notes
      • Django 1.8.3 release notes
      • Django 1.8.2 release notes
      • Django 1.8.1 release notes
      • Django 1.8 release notes
    • 1.7 release
      • Django 1.7.11 release notes
      • Django 1.7.10 release notes
      • Django 1.7.9 release notes
      • Django 1.7.8 release notes
      • Django 1.7.7 release notes
      • Django 1.7.6 release notes
      • Django 1.7.5 release notes
      • Django 1.7.4 release notes
      • Django 1.7.3 release notes
      • Django 1.7.2 release notes
      • Django 1.7.1 release notes
      • Django 1.7 release notes
    • 1.6 release
      • Django 1.6.11 release notes
      • Django 1.6.10 release notes
      • Django 1.6.9 release notes
      • Django 1.6.8 release notes
      • Django 1.6.7 release notes
      • Django 1.6.6 release notes
      • Django 1.6.5 release notes
      • Django 1.6.4 release notes
      • Django 1.6.3 release notes
      • Django 1.6.2 release notes
      • Django 1.6.1 release notes
      • Django 1.6 release notes
    • 1.5 release
      • Django 1.5.12 release notes
      • Django 1.5.11 release notes
      • Django 1.5.10 release notes
      • Django 1.5.9 release notes
      • Django 1.5.8 release notes
      • Django 1.5.7 release notes
      • Django 1.5.6 release notes
      • Django 1.5.5 release notes
      • Django 1.5.4 release notes
      • Django 1.5.3 release notes
      • Django 1.5.2 release notes
      • Django 1.5.1 release notes
      • Django 1.5 release notes
    • 1.4 release
      • Django 1.4.22 release notes
      • Django 1.4.21 release notes
      • Django 1.4.20 release notes
      • Django 1.4.19 release notes
      • Django 1.4.18 release notes
      • Django 1.4.17 release notes
      • Django 1.4.16 release notes
      • Django 1.4.15 release notes
      • Django 1.4.14 release notes
      • Django 1.4.13 release notes
      • Django 1.4.12 release notes
      • Django 1.4.11 release notes
      • Django 1.4.10 release notes
      • Django 1.4.9 release notes
      • Django 1.4.8 release notes
      • Django 1.4.7 release notes
      • Django 1.4.6 release notes
      • Django 1.4.5 release notes
      • Django 1.4.4 release notes
      • Django 1.4.3 release notes
      • Django 1.4.2 release notes
      • Django 1.4.1 release notes
      • Django 1.4 release notes
    • 1.3 release
      • Django 1.3.7 release notes
      • Django 1.3.6 release notes
      • Django 1.3.5 release notes
      • Django 1.3.4 release notes
      • Django 1.3.3 release notes
      • Django 1.3.2 release notes
      • Django 1.3.1 release notes
      • Django 1.3 release notes
    • 1.2 release
      • Django 1.2.7 release notes
      • Django 1.2.6 release notes
      • Django 1.2.5 release notes
      • Django 1.2.4 release notes
      • Django 1.2.3 release notes
      • Django 1.2.2 release notes
      • Django 1.2.1 release notes
      • Django 1.2 release notes
    • 1.1 release
      • Django 1.1.4 release notes
      • Django 1.1.3 release notes
      • Django 1.1.2 release notes
      • Django 1.1 release notes
    • 1.0 release
      • Django 1.0.2 release notes
      • Django 1.0.1 release notes
      • Django 1.0 release notes
    • Pre-1.0 releases
      • Django version 0.96 release notes
      • Django version 0.95 release notes
  • Security releases
• Django internals
  • Contributing to Django
    • Advice for new contributors
      • First steps
      • Guidelines
      • FAQ
    • Reporting bugs and requesting features
      • Reporting bugs
      • Reporting user interface bugs and features
      • Requesting features
      • How we make decisions
    • Triaging tickets
      • Triage workflow
      • Triage stages
      • Other triage attributes
      • Closing Tickets
      • How can I help with triaging?
      • Bisecting a regression
    • Writing code
      • Coding style
      • Unit tests
      • Submitting patches
      • Working with Git and GitHub
      • JavaScript
    • Writing documentation
      • Getting the raw documentation
      • Getting started with Sphinx
      • How the documentation is organized
      • Writing style
      • Commonly used terms
      • Django-specific terminology
      • Guidelines for reStructuredText files
      • Django-specific markup
      • Documenting new features
      • Minimizing images
      • An example
      • Spelling check
      • Translating documentation
      • django-admin man page
    • Localizing Django
      • Translations
      • Formats
      • Documentation
    • Committing code
      • Handling pull requests
      • Committing guidelines
      • Reverting commits
  • Mailing lists
    • django-users
    • django-core-mentorship
    • django-developers
    • django-i18n
    • django-announce
    • django-updates
  • Organization of the Django Project
    • Principles
    • Core team
      • Role
      • Prerogatives
      • Membership
    • Technical board
      • Role
      • Prerogatives
      • Membership
    • Changing the organization
  • Django team
    • The original team
    • The current team
    • Past team members
  • Roles
    • Technical board
    • Committers
    • Security team
    • Releasers
    • Ops team
  • Django’s security policies
    • Reporting security issues
    • Supported versions
    • How Django discloses security issues
    • Who receives advance notification
    • Requesting notifications
  • Django’s release process
    • Official releases
    • Release cadence
    • Deprecation policy
    • Supported versions
    • Release process
      • Release cycle
      • Bug-fix releases
  • Django Deprecation Timeline
    • 2.1
    • 2.0
    • 1.10
    • 1.9
    • 1.8
    • 1.7
    • 1.6
    • 1.5
    • 1.4
    • 1.3
  • The Django source code repository
    • High-level overview
    • The master branch
    • Other branches
      • Stable branches
      • Feature-development branches
    • Tags
  • How is Django Formed?
    • Overview
    • Prerequisites
    • Pre-release tasks
    • Preparing for release
    • Actually rolling the release
    • Making the release(s) available to the public
    • Post-release
    • New stable branch tasks
    • Notes on setting the VERSION tuple

Indices, glossary and tables

• Index
• Module Index
• Glossary

Last update:

Aug 25, 2016

up | next »