Django框架PDF英文版详解：入门与核心功能

需积分: 10 60 浏览量更新于2024-07-18 收藏 8.25MB PDF 举报

Django是Python编程语言中广泛使用的高级Web框架，它提供了强大的工具和模块化设计，使开发人员能够快速构建高效、可维护的Web应用。此文档是Django的英文官方文档，版本为Release 1.8.5.dev20150905183122，由Django Software Foundation发布于2015年9月5日。主要内容涵盖了以下几个关键部分： 1. **Django Documentation Overview**: 文档首先介绍了获取帮助的方式，包括官方网站、邮件列表、IRC频道以及在线社区。然后详细阐述了Django架构的三个核心层：模型层（Model Layer）、视图层（View Layer）和模板层（Template Layer），它们分别负责数据管理、逻辑处理和用户界面展示。 2. **Core Functionalities**: 除了基础架构，文档还涉及了Django的重要特性，如表单处理（Forms）、开发过程中的工作流、内置的管理界面（Admin）、安全性措施（Security）、国际化与本地化支持（Internationalization and Localization）、性能优化建议，以及对Python版本的兼容性说明。 3. **Getting Started**: 进入实战部分，文档提供了一个详细的教程，从初学者的角度逐步指导如何编写第一个Django应用程序，包括安装、环境配置，以及六个阶段的步骤，逐步展示如何创建数据库模型、定义视图、编写模板、处理表单和部署应用程序。 4. **Advanced Topics**: 高级教程探讨了如何编写可重用的应用组件，这是Django开发过程中一个重要的技能。此外，还提到了后续学习路径，以及如何参与到Django开源项目中，贡献代码或提交问题。 5. **Beyond the Basics**: 最后，文档列出了"下一步阅读"的内容，帮助读者根据自己的需求进一步深化理解和掌握Django。这份Django英文版文档为开发者提供了一个全面的指南，不仅涵盖了框架的基础知识，还包括实践操作和进阶技巧，是深入学习和实践Django的宝贵资源。通过阅读和跟随文档，开发者可以迅速掌握Django的架构原理，提高开发效率，并参与到活跃的开源社区中去。

Django Documentation, Release 1.8.5.dev20150905183122

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.5.dev20150905183122

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.5.dev20150905183122

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.5.dev20150905183122

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.5.dev20150905183122

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页未读，继续阅读

邓不利东

粉丝: 37
资源: 2

Django框架PDF英文版详解：入门与核心功能

Django Restful 框架设计规范 - 英文原文

Django最佳实践(Two scoops of django1.11) 高清PDF【英文版】

Django documentation（英文版）.pdf

Django文档（英文版）

facebook 外文文献

python参考文献

英文文献2017.pdf

Python django最佳实战 英文版

Python英文原版参考书集锦

Django类毕业设计-外文翻译

最新资源

Python django最佳实战英文版