Django 1.8 官方文档速览

5星 · 超过95%的资源需积分: 10 195 浏览量更新于2024-07-21 1 收藏 5.84MB PDF 举报

"django_v1.8.pdf 是 Django 框架的官方文档，主要针对 Django 1.8 版本。文档包含了丰富的教程和指南，涵盖了从入门到进阶的多个方面，如模型、视图、模板、表单、开发流程、管理后台、安全、国际化与本地化、性能优化、Python 兼容性、地理框架以及常用Web应用工具等核心功能。文档还提供了快速安装指南和一系列逐步教程，帮助用户从零开始创建第一个 Django 应用，并有高级教程讲解如何编写可重用的应用。此外，还有关于如何为 Django 贡献代码的指导。" Django 是一个基于 Python 的高性能 Web 开发框架，其设计哲学是“清晰的表述比模糊的聪明才智更重要”。在 Django 1.8 文档中，以下几个关键知识点值得深入学习： 1. **模型（Model）层**：Django 的数据模型是 ORM（对象关系映射）的一部分，允许开发者使用 Python 类定义数据库结构。模型类定义了数据库表格的字段和行为。 2. **视图（View）层**：视图是处理用户请求并返回响应的部分。Django 视图通常是 Python 函数或类，它们根据用户请求获取数据并返回HTML页面或其他类型的数据。 3. **模板（Template）层**：模板系统是一种声明式语言，用于描述动态HTML。它允许开发者将静态内容与动态数据分离。 4. **表单（Forms）**：Django 提供了强大的表单处理功能，可以自动生成HTML表单，验证用户输入，并将数据保存到数据库。 5. **开发过程**：包括开发服务器、调试工具、测试框架等，支持快速迭代和高质量的代码开发。 6. **管理后台（Admin）**：Django 自带了一个自动化的管理界面，用于数据的增删改查，无需编写额外代码。 7. **安全性**：Django 内置了防止SQL注入、跨站脚本攻击等的安全机制，但开发者仍需了解并遵循最佳实践。 8. **国际化与本地化（Internationalization & Localization）**：Django 支持多语言应用，包括翻译文本和日期/时间格式化。 9. **性能优化**：包括缓存策略、数据库查询优化等，有助于提高应用性能。 10. **Python 兼容性**：Django 1.8 支持的 Python 版本范围，以及可能的兼容性问题。 11. **地理框架**：Django 提供了处理地理位置数据的支持，如地理数据库和地图服务。 12. **常见Web应用工具**：包括电子邮件发送、URL路由、中间件等，这些是构建Web应用的基础组件。 13. **其他核心功能**：如中间件、信号处理器、管理命令等，扩展了 Django 的核心功能。这份文档对于初学者和经验丰富的开发者来说都是宝贵的资源，它不仅提供了详尽的教程，还涵盖了 Django 的核心特性和最佳实践。通过阅读和实践，开发者可以快速掌握 Django 并高效地开发 Web 应用。

Django Documentation, Release 1.8.7.dev20151104171001

The code above maps URLs, as simple regular expressions, to the location of Python callback functions (“views”).

The regular expressions use parenthesis to “capture” values from the URLs. When a user requests a page, Django runs

through each pattern, in order, and stops at the ﬁrst one that matches the requested URL. (If none of them matches,

Django calls a special-case 404 view.) This is blazingly fast, because the regular expressions are compiled at load

time.

Once one of the regexes matches, Django imports and calls the given view, which is a simple Python function. Each

view gets passed a request object – which contains request metadata – and the values captured in the regex.

For example, if a user requested the URL “/articles/2005/05/39323/”, Django would call the function

news.views.article_detail(request, ’2005’, ’05’, ’39323’).

2.1.6 Write your views

Each view is responsible for doing one of two things: Returning an HttpResponse object containing the content

for the requested page, or raising an exception such as Http404. The rest is up to you.

Generally, a view retrieves data according to the parameters, loads a template and renders the template with the

retrieved data. Here’s an example view for year_archive from above: from django.shortcuts import render

from .models import Article

def year_archive(request, year): a_list = Article.objects.ﬁlter(pub_date__year=year) context =

{‘year’: year, ‘article_list’: a_list} return render(request, ‘news/year_archive.html’, context)

mysite/news/views.py

This example uses Django’s template system, which has several powerful features but strives to stay simple enough

for non-programmers to use.

2.1.7 Design your templates

The code above loads the news/year_archive.html template.

Django has a template search path, which allows you to minimize redundancy among templates. In your Django

settings, you specify a list of directories to check for templates with DIRS. If a template doesn’t exist in the ﬁrst

directory, it checks the second, and so on.

Let’s say the news/year_archive.html template was found. Here’s what that might look like: {% extends

“base.html” %}

{% block title %}Articles for {{ year }}{% endblock %}

{% block content %} <h1>Articles for {{ year }}</h1>

{% for article in article_list %} <p>{{ article.headline }}</p> <p>By {{ article.reporter.full_name

}}</p> <p>Published {{ article.pub_date|date:”F j, Y” }}</p> {% endfor %} {% endblock %}

mysite/news/templates/news/year

𝑎

𝑟𝑐ℎ𝑖𝑣𝑒.ℎ𝑡𝑚𝑙

Variables are surrounded by double-curly braces. {{ article.headline }} means “Output the value of the

article’s headline attribute.” But dots aren’t used only for attribute lookup. They also can do dictionary-key lookup,

index lookup and function calls.

10 Chapter 2. Getting started

Django Documentation, Release 1.8.7.dev20151104171001

Note {{ article.pub_date|date:"F j, Y" }} uses a Unix-style “pipe” (the “|” character). This is called

a template ﬁlter, and it’s a way to ﬁlter the value of a variable. In this case, the date ﬁlter formats a Python datetime

object in the given format (as found in PHP’s date function).

You can chain together as many ﬁlters as you’d like. You can write custom template ﬁlters. You can write custom

template tags, which run custom Python code behind the scenes.

Finally, Django uses the concept of “template inheritance”. That’s what the {% extends "base.html" %}

does. It means “First load the template called ‘base’, which has deﬁned a bunch of blocks, and ﬁll the blocks with

the following blocks.” In short, that lets you dramatically cut down on redundancy in templates: each template has to

deﬁne only what’s unique to that template.

Here’s what the “base.html” template, including the use of static ﬁles, might look like: {% load static-

ﬁles %} <html> <head> <title>{% block title %}{% endblock %}</title> </head> <body> <img src=”{%

static “images/sitelogo.png” %}” alt=”Logo” /> {% block content %}{% endblock %} </body> </html>

mysite/templates/base.html

Simplistically, it deﬁnes the look-and-feel of the site (with the site’s logo), and provides “holes” for child templates to

ﬁll. This makes a site redesign as easy as changing a single ﬁle – the base template.

It also lets you create multiple versions of a site, with different base templates, while reusing child templates. Django’s

creators have used this technique to create strikingly different mobile versions of sites – simply by creating a new base

template.

Note that you don’t have to use Django’s template system if you prefer another system. While Django’s template

system is particularly well-integrated with Django’s model layer, nothing forces you to use it. For that matter, you

don’t have to use Django’s database API, either. You can use another database abstraction layer, you can read XML

ﬁles, you can read ﬁles off disk, or anything you want. Each piece of Django – models, views, templates – is decoupled

from the next.

2.1.8 This is just the surface

This has been only a quick overview of Django’s functionality. Some more useful features:

• A caching framework that integrates with memcached or other backends.

• A syndication framework that makes creating RSS and Atom feeds as easy as writing a small Python class.

• More sexy automatically-generated admin features – this overview barely scratched the surface.

The next obvious steps are for you to download Django, read the tutorial and join the community. Thanks for your

interest!

2.2 Quick install guide

Before you can use Django, you’ll need to get it installed. We have a complete installation guide that covers all

the possibilities; this guide will guide you to a simple, minimal installation that’ll work while you walk through the

introduction.

2.2.1 Install Python

Being a Python Web framework, Django requires Python. See What Python version can I use with Django? for details.

Python includes a lightweight database called SQLite so you won’t need to set up a database just yet.

2.2. Quick install guide 11

Django Documentation, Release 1.8.7.dev20151104171001

Get the latest version of Python at https://www.python.org/download/ or with your operating system’s package man-

ager.

Django on Jython

If you use Jython (a Python implementation for the Java platform), you’ll need to follow a few additional steps. See

Running Django on Jython for details.

You can verify that Python is installed by typing python from your shell; you should see something like:

Python 3.3.3 (default, Nov 26 2013, 13:33:18)

[GCC 4.8.2] on linux

Type "help", "copyright", "credits" or "license" for more information.

>>>

2.2.2 Set up a database

This step is only necessary if you’d like to work with a “large” database engine like PostgreSQL, MySQL, or Oracle.

To install such a database, consult the database installation information.

2.2.3 Remove any old versions of Django

If you are upgrading your installation of Django from a previous version, you will need to uninstall the old Django

version before installing the new version.

2.2.4 Install Django

You’ve got three easy options to install Django:

• Install a version of Django provided by your operating system distribution. This is the quickest option for those

who have operating systems that distribute Django.

• Install an ofﬁcial release. This is the best approach for most users.

• Install the latest development version. This option is for enthusiasts who want the latest-and-greatest features

and aren’t afraid of running brand new code. You might encounter new bugs in the development version, but

reporting them helps the development of Django. Also, releases of third-party packages are less likely to be

compatible with the development version than with the latest stable release.

Always refer to the documentation that corresponds to the version of Django you’re using!

If you do either of the ﬁrst two steps, keep an eye out for parts of the documentation marked new in development

version. That phrase ﬂags features that are only available in development versions of Django, and they likely won’t

work with an ofﬁcial release.

2.2.5 Verifying

To verify that Django can be seen by Python, type python from your shell. Then at the Python prompt, try to import

Django:

>>> import django

>>> print(django.get_version())

1.8

12 Chapter 2. Getting started

Django Documentation, Release 1.8.7.dev20151104171001

You may have another version of Django installed.

2.2.6 That’s it!

That’s it – you can now move onto the tutorial.

2.3 Writing your ﬁrst Django app, part 1

Let’s learn by example.

Throughout this tutorial, we’ll walk you through the creation of a basic poll application.

It’ll consist of two parts:

• A public site that lets people view polls and vote in them.

• An admin site that lets you add, change and delete polls.

We’ll assume you have Django installed already. You can tell Django is installed and which version by running the

following command:

$ python -c "import django; print(django.get_version())"

If Django is installed, you should see the version of your installation. If it isn’t, you’ll get an error telling “No module

named django”.

This tutorial is written for Django 1.8 and Python 3.2 or later. If the Django version doesn’t match, you can refer to

the tutorial for your version of Django by using the version switcher at the bottom right corner of this page, or update

Django to the newest version. If you are still using Python 2.7, you will need to adjust the code samples slightly, as

described in comments.

See How to install Django for advice on how to remove older versions of Django and install a newer one.

Where to get help:

If you’re having trouble going through this tutorial, please post a message to django-users or drop by #django on

irc.freenode.net to chat with other Django users who might be able to help.

2.3.1 Creating a project

If this is your ﬁrst time using Django, you’ll have to take care of some initial setup. Namely, you’ll need to auto-

generate some code that establishes a Django project – a collection of settings for an instance of Django, including

database conﬁguration, Django-speciﬁc options and application-speciﬁc settings.

From the command line, cd into a directory where you’d like to store your code, then run the following command:

$ django-admin startproject mysite

This will create a mysite directory in your current directory. If it didn’t work, see Problems running django-admin.

Note: You’ll need to avoid naming projects after built-in Python or Django components. In particular, this means

you should avoid using names like django (which will conﬂict with Django itself) or test (which conﬂicts with a

built-in Python package).

Where should this code live?

2.3. Writing your ﬁrst Django app, part 1 13

Django Documentation, Release 1.8.7.dev20151104171001

If your background is in plain old PHP (with no use of modern frameworks), you’re probably used to putting code

under the Web server’s document root (in a place such as /var/www). With Django, you don’t do that. It’s not a

good idea to put any of this Python code within your Web server’s document root, because it risks the possibility that

people may be able to view your code over the Web. That’s not good for security.

Put your code in some directory outside of the document root, such as /home/mycode.

Let’s look at what startproject created:

mysite/

manage.py

mysite/

__init__.py

settings.py

urls.py

wsgi.py

These ﬁles are:

• The outer mysite/ root directory is just a container for your project. Its name doesn’t matter to Django; you

can rename it to anything you like.

• manage.py: A command-line utility that lets you interact with this Django project in various ways. You can

read all the details about manage.py in django-admin and manage.py.

• The inner mysite/ directory is the actual Python package for your project. Its name is the Python package

name you’ll need to use to import anything inside it (e.g. mysite.urls).

• mysite/__init__.py: An empty ﬁle that tells Python that this directory should be considered a Python

package. (Read more about packages in the ofﬁcial Python docs if you’re a Python beginner.)

• mysite/settings.py: Settings/conﬁguration for this Django project. Django settings will tell you all

about how settings work.

• mysite/urls.py: The URL declarations for this Django project; a “table of contents” of your Django-

powered site. You can read more about URLs in URL dispatcher.

• mysite/wsgi.py: An entry-point for WSGI-compatible web servers to serve your project. See How to

deploy with WSGI for more details.

Database setup

Now, open up mysite/settings.py. It’s a normal Python module with module-level variables representing

Django settings.

By default, the conﬁguration uses SQLite. If you’re new to databases, or you’re just interested in trying Django, this is

the easiest choice. SQLite is included in Python, so you won’t need to install anything else to support your database.

When starting your ﬁrst real project, however, you may want to use a more robust database like PostgreSQL, to avoid

database-switching headaches down the road.

If you wish to use another database, install the appropriate database bindings, and change the following keys in the

DATABASES ’default’ item to match your database connection settings:

• ENGINE – Either ’django.db.backends.sqlite3’, ’django.db.backends.postgresql_psycopg2’,

’django.db.backends.mysql’, or ’django.db.backends.oracle’. Other backends are also

available.

• NAME – The name of your database. If you’re using SQLite, the database will be a ﬁle on your computer;

in that case, NAME should be the full absolute path, including ﬁlename, of that ﬁle. The default value,

os.path.join(BASE_DIR, ’db.sqlite3’), will store the ﬁle in your project directory.

14 Chapter 2. Getting started

剩余1578页未读，继续阅读

ilovelibai

粉丝: 4

Django 1.8 官方文档速览

Django 1.8.16

Django-1.8.17

Django-1.8.18 for python

Django 中文文档 1.8.pdf

Two-Scoops-of-Django_-Best-Practices-for-Django-1.8.pdf 高清无水印

Django_by_Example.pdf.pdf

Python库 | sqlany_django-1.8.tar.gz

精通Django.Django 1.8 LTS全解.pdf

Django_book_2_中文版.pdf

Python_django_cheatsheet.zip_python_specialhx8_zip

最新资源

Two-Scoops-of-Django_-Best-Practices-for-Django-1.8.pdf　高清无水印