Django 1.8官方文档：入门与核心功能详解

django

4星 · 超过85%的资源需积分: 10 23 浏览量更新于2024-07-22 收藏 5.79MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

Django官方文档1.8是Django软件基金会发布的一份全面的指南，旨在帮助开发者深入了解和掌握这个流行的Python web框架。这份文档详细介绍了Django的各个核心组件，包括模型层、视图层、模板层，以及如何利用它们构建高效、安全和国际化的web应用。 1.1 获得帮助：文档首先提供了获取支持的方式，包括官方论坛、邮件列表和Stack Overflow等社区资源，以便用户在遇到问题时能快速获得解答。 1.2 第一步：初学者可以从中找到入门教程，从Django概述开始，了解其设计理念和架构，为后续学习打下基础。 1.3 模型层：这部分讲解了如何定义和管理数据库模型，包括模型类的设计、字段类型和关系设置，以及如何进行数据迁移和验证。 1.4 视图层：这部分涵盖了视图函数和类视图的概念，如何处理HTTP请求，以及如何利用中间件实现更复杂的逻辑控制。 1.5 模板层：文档深入解析了Django模板语言，如何使用模板继承、条件语句、循环和模板标签来展示动态内容。 1.6 表单：介绍如何创建和使用Django的表单系统，包括内置的Form类、ModelForm以及自定义表单处理。 1.7 开发过程：这部分涉及Django的开发模式、单元测试和调试技巧，帮助开发者编写高质量的代码。 1.8 管理员界面：文档解释了如何使用内置的admin工具进行模型管理，以及如何定制自己的管理后台。 1.9 安全性：讨论了身份验证、授权和加密等关键安全措施，确保web应用的稳定运行。 1.10 国际化与本地化：涵盖了如何处理多语言环境，包括日期时间格式、翻译和区域设置。 1.11 性能与优化：提供了一些性能调优策略，如缓存、数据库查询优化和静态文件管理。 1.12 Python兼容性：确保读者了解Django与不同Python版本的兼容性，以及可能遇到的问题。 1.13 地理框架：介绍了如何在Django中集成地理位置功能，如使用GeoDjango库。 1.14 共享web应用工具：涵盖了第三方应用、API设计和RESTful接口的使用。 1.15 其他核心功能：文档还列出了其他重要的功能，如会话管理、邮件发送和静态文件管理等。 1.16 Django开源项目：阐述了Django作为一个活跃的开源社区，如何贡献代码、参与讨论和贡献到社区发展中。 2.1 开始使用Django：从快速安装引导开始，逐步引导开发者创建第一个Django应用，通过实践理解框架的核心概念。通过阅读这份详细的官方文档，无论是初次接触Django的新手还是经验丰富的开发者，都能找到适合自己的学习路径，掌握Django的强大功能，为构建高效、现代的web应用奠定坚实的基础。

资源详情

资源推荐

Django Documentation, Release 1.8.dev20141019172248

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 TEMPLATE_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.dev20141019172248

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. It works with Python 2.7, 3.2, 3.3, or 3.4. All these versions

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

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

2.2. Quick install guide 11

Django Documentation, Release 1.8.dev20141019172248

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 users who want a stable version number and aren’t

concerned about running a slightly older version of Django.

• Install the latest development version. This is best for users who want the latest-and-greatest features and aren’t

afraid of running brand-new code.

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

You may have another version of Django installed.

12 Chapter 2. Getting started

Django Documentation, Release 1.8.dev20141019172248

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?

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

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

Django Documentation, Release 1.8.dev20141019172248

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, edit 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.

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.

If you are not using SQLite as your database, additional settings such as USER, PASSWORD, HOST must be added.

For more details, see the reference documentation for DATABASES.

14 Chapter 2. Getting started

剩余1566页未读，继续阅读

以墨言智

粉丝: 170
资源: 2

Django 1.8官方文档：入门与核心功能详解

django 1.8.2官方中文文档

Django-1.11.7.tar.gz

学习django推荐书籍和资料

Django1.8中间件的几种魔术方法

django4.0中文文档

Django1.8中如何使用数据库连接池

django1.8 redis cache 的默认配置

django1.8版本怎么设置频率控制

升级Django版本代码

django1.8中使用redis作为缓存服务器，怎么配置

Django1.8中通过装饰器完成事务控制

Django1.8中怎么开始事务

django3.1中文文档html版下载

怎样学习django框架

新手怎么正式学习 Django框架

django的General Index

Django 文档中关于缓存机制的部分介绍

django.db使用文档

基于django的工作网代码

Django1.8中通过Redis如何实现接口访问频率限制

最新资源