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
- Django at a glance (CSDN 有一个哥们已经翻译了。。。)
-
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
- The
- Cryptographic signing
- Protecting the
SECRET_KEY
- Using the low-level API
- Protecting the
- 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 install Django (该页已经翻译完成,差14个链接页未翻译 Page 17)
- “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
andvirtualenvwrapper
- 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
- Authentication using
- 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
- Problems running
- FAQ: General
- 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
andmanage.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
- The
- 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
andSimpleTemplateResponse
-
SimpleTemplateResponse
objects -
TemplateResponse
objects - The rendering process
- Using
TemplateResponse
andSimpleTemplateResponse
-
- Unicode data
- Creating the database
- General string handling
- Models
- The database API
- Templates
- Files
- Form submission
-
django.urls
utility functionsreverse()
reverse_lazy()
resolve()
get_script_prefix()
-
django.urls
functions for use in URLconfspath()
re_path()
include()
register_converter()
-
django.conf.urls
functions for use in URLconfsstatic()
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
- Applications
- 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
- API stability
- 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
- Final 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
- Contributing to Django
Indices, glossary and tables
- Index
- Module Index
- Glossary