Django 2.0.1 官方文档翻译: 文档目录 (Page 1)

Django documentation contents

翻译完成后会做标记。
文档按照官方提供的内容一页一页的进行翻译，有些内容涉及到其他节的内容，会慢慢补上。所有的翻译内容按自己的理解来写，尽量做到“信达雅”。也算是给自己学习英语提供一个好的方式，既能助人又能利己。

Getting started

Django at a glance （CSDN 有一个哥们已经翻译了。。。）

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 (该页翻译完成 Page 5)

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 （该页面翻译完成，缺少外联页面 （Page 6））

Creating a project

The development server

Creating the Polls app

Write your first view

Writing your first Django app, part 2 （该页面翻译完成，缺少外联页面 （Page 7））

Database setup

Creating models

Activating models

Playing with the API

Introducing the Django Admin

Writing your first Django app, part 3 （该页面翻译完成，缺少外联页面 （Page 8））

Overview

Writing more views

Write views that actually do something

Raising a 404 error

Use the template system

Removing hardcoded URLs in templates

Namespacing URL names

Writing your first Django app, part 4 （该页面翻译完成，缺少外联页面 （Page 9））

Write a simple form

Use generic views: Less code is better

Writing your first Django app, part 5（该页面翻译完成，缺少外联页面 （Page 10））

Introducing automated testing

Basic testing strategies

Writing our first test

Test a view

When testing, more is better

Further testing

What’s next?

Writing your first Django app, part 6 （该页面翻译完成，缺少外联页面 （Page 11））

Customize your app’s look and feel

Adding a background-image

Writing your first Django app, part 7 （该页面翻译完成，缺少外联页面 （Page 12））

Customize the admin form

Adding related objects

Customize the admin change list

Customize the admin look and feel

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

Differences between versions

Writing your first patch for Django

Introduction

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

Creating a branch for your patch

Writing some tests for your ticket

Writing the code for your ticket

Running Django’s test suite for the second time

Writing Documentation

Previewing your changes

Committing the changes in the patch

Pushing the commit and making a pull request

Next steps

Using Django

How to install Django （该页已经翻译完成，差14个链接页未翻译 Page 17）

Install Python

Install Apache and

mod_wsgi

Get your database running

Remove any old versions of Django

Install the Django code

Models and databases

Models

Making queries

Aggregation

Search

Managers

Performing raw SQL queries

Database transactions

Multiple databases

Tablespaces

Database access optimization

Database instrumentation

Examples of model relationship API usage

Handling HTTP requests

URL dispatcher

Writing views

View decorators

File Uploads

Django shortcut functions

Generic views

Middleware

How to use sessions

Working with forms

HTML forms

Django’s role in forms

Forms in Django

Building a form

More about Django

Form

classes

Working with form templates

Further topics

Templates

Support for template engines

The Django template language

Class-based views

Introduction to class-based views

Built-in class-based generic views

Form handling with class-based views

Using mixins with class-based views

Basic examples

Simple usage in your URLconf

Subclassing generic views

Migrations

The Commands

Backend Support

Workflow

Dependencies

Migration files

Adding migrations to apps

Historical models

Considerations when removing model fields

Data Migrations

Squashing migrations

Serializing values

Supporting multiple Django versions

Managing files

Using files in models

The

File

object

File storage

Testing in Django

Writing and running tests

Testing tools

Advanced testing topics

User authentication in Django

Overview

Installation

Usage

Django’s cache framework

Setting up the cache

The per-site cache

The per-view cache

Template fragment caching

The low-level cache API

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

Using the decorators with other HTTP methods

Comparison with middleware conditional processing

Cryptographic signing

Protecting the

SECRET_KEY

Using the low-level API

Sending email

Quick example

send_mail()

send_mass_mail()

mail_admins()

mail_managers()

Examples

Preventing header injection

The

EmailMessage

class

Email backends

Configuring email for development

Internationalization and localization

Overview

Definitions

Logging

A quick logging primer

Using logging

Configuring logging

Django’s logging extensions

Django’s default logging configuration

Pagination

Example

Using

Paginator

in a view

Paginator

objects

InvalidPage

exceptions

Page

objects

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

Caching

Understanding laziness

Databases

HTTP performance

Template performance

Using different versions of available software

Serializing Django objects

Serializing data

Deserializing data

Serialization formats

Natural keys

Django settings

The basics

Designating the settings

Default settings

Using settings in Python code

Altering settings at runtime

Security

Available settings

Creating your own settings

Using settings without setting

DJANGO_SETTINGS_MODULE

Signals

Listening to signals

Defining and sending signals

Disconnecting signals

System check framework

Writing your own checks

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

Overriding commands

Command objects

Writing custom model fields

Introduction

Background theory

Writing a field subclass

Writing a

FileField

subclass

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

Writing custom template tags

Writing a custom storage system

Deploying Django

How to deploy with WSGI

Deployment checklist

Upgrading Django to a newer version

Required Reading

Dependencies

Resolving deprecation warnings

Installation

Testing

Deployment

Error reporting

Email reports

Filtering error reports

Providing initial data for models

Providing initial data with fixtures

Providing initial data with migrations

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

Using the template system

Other text-based formats

Outputting PDFs with Django

Install ReportLab

Write your view

Complex PDFs

Other formats

Overriding templates

Overriding from the project’s templates directory

Overriding from an app’s template directory

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

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

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?

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 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

Miscellaneous

API Reference

Applications

Projects and applications

Configuring applications

Application configuration

Application registry

Initialization process

System check framework

API reference

Builtin tags

Core system checks

contrib

app checks

Built-in class-based views API

Base views

Generic display views

Generic editing views

Generic date views

Class-based views mixins

Class-based generic views - flattened index

Specification

Base vs Generic views

Clickjacking Protection

An example of clickjacking

Preventing clickjacking

How to use it

Limitations

contrib

packages

The Django admin site

django.contrib.auth

The contenttypes framework

The flatpages app

GeoDjango

django.contrib.humanize

The messages framework

django.contrib.postgres

The redirects app

The sitemap framework

The “sites” framework

The

staticfiles

app

The syndication feed 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

Rejected requests

How it works

Caching

Testing

Limitations

Edge cases

Contrib and reusable apps

Settings

Frequently Asked Questions

Databases

General notes

PostgreSQL notes

MySQL notes

SQLite notes

Oracle notes

Using a 3rd-party database backend

django-admin

and

manage.py

Usage

Available commands

Commands provided by applications

Default options

Extra niceties

Running management commands from your code

Output redirection

Django Exceptions

Django Core Exceptions

URL Resolver exceptions

Database Exceptions

Http Exceptions

Transaction Exceptions

Testing Framework Exceptions

Python Exceptions

File handling

The

File

object

File storage API

Uploaded Files and Upload Handlers

Forms

The Forms API

Form fields

Model Form Functions

Formset Functions

The form rendering API

Widgets

Form and field validation

Middleware

Available middleware

Middleware ordering

Migration Operations

Schema Operations

Special Operations

Writing your own

Models

Model field reference

Field attribute reference

Model index reference

Model

_meta

API

Related objects reference

Model class reference

Model

Meta

options

Model instance reference

QuerySet

API reference

Lookup API reference

Query Expressions

Conditional Expressions

Database Functions

Request and response objects

Quick overview

HttpRequest

objects

QueryDict

objects

HttpResponse

objects

JsonResponse

objects

StreamingHttpResponse

objects

FileResponse

objects

SchemaEditor

Methods

Attributes

Settings

Core Settings

Auth

Messages

Sessions

Sites

Static Files

Core Settings Topical Index

Signals

Model signals

Management signals

Request/response signals

Test signals

Database Wrappers

Templates

The Django template language

Built-in template tags and filters

The Django template language: for Python programmers

TemplateResponse

and

SimpleTemplateResponse

SimpleTemplateResponse

objects

TemplateResponse

objects

The rendering process

Using

TemplateResponse

and

SimpleTemplateResponse

Unicode data

Creating the database

General string handling

Models

The database API

Templates

Files

Form submission

django.urls

utility functions

reverse()

reverse_lazy()

resolve()

get_script_prefix()

django.urls

functions for use in URLconfs

path()

re_path()

include()

register_converter()

django.conf.urls

functions for use in URLconfs

static()

url()

handler400

handler403

handler404

handler500

Django Utils

django.utils.cache

django.utils.dateparse

django.utils.decorators

django.utils.encoding

django.utils.feedgenerator

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

Built-in Views

Serving files in development

Error views

Meta-documentation and miscellany

API stability

What “stable” means

Stable APIs

Exceptions

Design philosophies

Overall

Models

Database API

URL design

Template system

Views

Cache Framework

Third-party distributions of Django

For distributors

Glossary

Release notes

Final releases

2.0 release

1.11 release

1.10 release

1.9 release

1.8 release

1.7 release

1.6 release

1.5 release

1.4 release

1.3 release

1.2 release

1.1 release

1.0 release

Pre-1.0 releases

Security releases

Django internals

Contributing to Django

Advice for new contributors

Reporting bugs and requesting features

Triaging tickets

Writing code

Writing documentation

Localizing Django

Committing code

Mailing lists

django-users

django-core-mentorship

django-developers

django-i18n

django-announce

django-updates

Organization of the Django Project

Principles

Core team

Technical board

Changing the organization

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

Django Deprecation Timeline

3.0

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

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