深入探索Django Web开发：Pro Django

需积分: 0 179 浏览量更新于2024-08-01 收藏 996KB PDF 举报

"Pro Django 是一本专为已经具备基础的开发者设计的深入讲解Django Web框架的书籍，作者是Marty Alchin。本书探讨了如何高效地利用Django进行复杂Web开发，旨在帮助读者提升Django应用的专业技能。" 在《Pro Django》一书中，作者Marty Alchin深入探讨了Django框架的高级特性和实践技巧，这不仅包括Django的基础知识，还涵盖了如何构建复杂的Web应用程序。以下是一些关键的知识点： 1. **模型(Model)**：Django的核心之一是其ORM（对象关系映射）系统，通过模型定义数据库结构。书中详细讲解了如何创建、管理以及优化数据模型，包括字段类型、关系处理、查询操作和自定义方法。 2. **视图(View)**：视图是Django处理HTTP请求并生成响应的部分。书中会阐述如何编写高效、可重用的视图函数和类，以及如何使用通用视图和CBV（Class-Based Views）来简化代码。 3. **模板(Templates)**：Django的模板系统允许开发者创建动态HTML。书中会涵盖模板语言的基本语法、继承、过滤器、标签和如何与JavaScript交互。 4. **URL路由(URLConf)**：Django的URL配置系统使得URL设计简洁且可维护。书中将介绍如何定义URL模式、使用正则表达式以及处理命名空间和别名。 5. **表单和验证(Forms and Validation)**：Django提供了一套强大的表单处理机制。读者将学习如何创建表单、验证用户输入、自定义错误消息以及如何在模板中渲染表单。 6. **中间件(Middleware)**：中间件是Django中一种特殊组件，用于扩展或修改框架的行为。书中会讲述何时及如何编写和使用中间件，以及它们在处理请求和响应中的作用。 7. **缓存(Caching)**：为了提高性能，Django提供了多种缓存机制。这部分将涵盖页面缓存、片段缓存、数据库查询缓存和Memcached的使用。 8. **部署和性能优化(Deployment and Performance Tuning)**：书籍会讲解如何将Django项目部署到生产环境，包括服务器配置、性能监控和优化策略。 9. **第三方应用(Third-Party Applications)**：Django社区提供了大量高质量的第三方应用，如Django Rest Framework用于API开发，Celery进行异步任务处理等。书中可能会介绍一些常用的库和如何集成它们。 10. **安全(Security)**：Django内置了多种安全特性，如CSRF保护、XSS防护和SQL注入预防。这部分会讲解如何确保你的Django应用是安全的。技术审阅者Jacob Kaplan-Moss和George Vilches的参与确保了书中的内容准确且符合当前Django的最佳实践。此外，Apress出版社的编辑团队，如Steve Anglin和Editorial Board成员，也为书籍的编校和质量把关做出了贡献。这本书适合那些已经熟悉Python和Web开发基础，希望进一步提升Django技能的开发者。通过阅读《Pro Django》，你可以掌握Django的高级特性和最佳实践，从而更好地构建和维护复杂的Web应用程序。

xix

Introduction

Pro Django represents two and a half years of accumulated knowledge in Python and Django,

designed to educate readers who are already familiar with both topics and would like to take

them further than they had previously done. You will learn a wide range of advanced tech-

niques available in both Python and Django, along with tips on how to use them to achieve

advanced functionality.

This book is designed to be both a narrative to be read from start to finish and a general

reference to be searched for specific information. Since you may not know what to look for or

where to find it yet, feel free to read through the book first, then keep it handy for refreshing

your memory as necessary.

What This Book Is Not

There are plenty of resources available for learning Python and Django, so this book does not

strive to teach the basics. For readers new to Python, I highly recommend Dive Into Python

by Mark Pilgrim (Apress, 2004). For learning Django, I’d recommend The Definitive Guide to

Django: Web Development Done Right by Adrian Holovaty and Jacob Kaplan-Moss (Apress,

2006). Additionally, Practical Django Projects by James Bennett (Apress, 2008) is an excellent

resource for general application development.

Who This Book Is For

Because Pro Django doesn’t dwell on introductory details, readers will be expected to have

experience with both Python and Django. If you’re new to either subject, please consider one

of the books mentioned in the previous section before trying to tackle this book.

Even if you’ve only experimented on your own without launching a full site yet, a basic

familiarity should be sufficient. You don’t need to be an expert to start reading Pro Django, but

you might be by the time you finish.

Interpreting Code Samples

Pro Django uses a simple format, interleaving explanations of Python’s and Django’s available

features with code that demonstrates their use in the real world. There are two types of code

samples used, which differ in how they should be executed.

Python’s interactive interpreter is a great way to test out small pieces of code and see

how it works in a variety of situations. Lines of code intended for use in that environment will

always be prefixed with three characters: three greater-than signs (:::) or three periods (***).

Lines with greater-than signs are the outermost block of code, while the period-prefixed lines

are indented at least one level. The three initial characters are also followed by a space. These

CHAPTER 1

Understanding Django

Code alone isn’t enough. Sure, it’s what the computer runs, but code has to come from

somewhere. A programmer has to sit down and decide what features to include, how they

should be implemented, what other software to utilize and how to provide hooks for future

enhancements to be added. It’s easy to skip straight to code, ignoring the cognitive process

that produces it, but great programmers always have reasons for the decisions they make.

With a framework, like Django, many such decisions have already been made, and the

tools provided are shaped by these decisions and by the programmers who made them. By

adopting these philosophies in your own code, not only will you be consistent with Django

and other applications, but you may even be amazed at what you’re able to accomplish.

Beneath even the most fundamental code is the thought process that went into its cre-

ation. Decisions were made about what it should do and how it should do it. This thought

process is a step often overlooked in books and manuals, leading to an army of technicians

slaving away, writing code that manages to accomplish the task at hand but without a vision

for its future.

While the rest of this book will explain in detail the many basic building blocks Django

provides for even the most complicated of projects, this chapter will focus on these even more

fundamental aspects of the framework. For those readers coming from other backgrounds, the

ideas presented in this chapter may seem considerably foreign, but that doesn’t make them

any less important. All programmers working with Python and Django would do well to have

solid understanding of the reasons Django works the way it does, and how those principles

can be applied to other projects.

You may want to read this chapter more than once, and perhaps refer to it often as you

work with Django. Many of the topics covered in this chapter are common knowledge in the

Django community, so reading this chapter carefully is essential if you plan to interact with

other programmers.

Philosophy

Django relies heavily on philosophy, both in how its code is written and how decisions are

made about what goes into the framework. This isn’t unique in programming, but it’s some-

thing newcomers often have trouble with. It is essential to maintain both consistency and

quality, and having a set of common philosophies to refer to when making decisions helps

maintain both. Since these concepts are also important to individual applications, and even

collections of applications, a firm grasp on these philosophies will yield similar benefits.

CHAPTER 1 ฀ UNDERSTANDING DJANGO

Perhaps the best- known and most- quoted passage of Python philosophy comes from Tim

Peters, a longtime Python guru who wrote down many of the principles that guide Python’s own

development process. The 19 lines he came up with have been so influential to Python program-

mers over time that they are immortalized as Python Enhancement Proposal (PEP) 20

and in

the Python distribution itself, as an “easter egg” module called pdeo.

:::eilknppdeo

>a]qpebqheo^appanpd]jqchu*

Atlhe_epeo^appanpd]jeilhe_ep*

Oeilhaeo^appanpd]j_kilhat*

?kilhateo^appanpd]j_kilhe_]pa`*

Bh]peo^appanpd]jjaopa`*

Ol]noaeo^appanpd]j`ajoa*

Na]`]^ehepu_kqjpo*

Ola_e]h_]oao]naj#pola_e]hajkqcdpk^na]gpdanqhao*

=hpdkqcdln]_pe_]hepu^a]polqnepu*

Annknoodkqh`jaranl]oooehajphu*

Qjhaooatlhe_ephuoehaj_a`*

Ejpdab]_akb]i^ecqepu(nabqoapdapailp]pekjpkcqaoo*

Pdanaodkqh`^akja))]j`lnaban]^hukjhukja))k^rekqos]upk`kep*

=hpdkqcdpd]ps]ui]ujkp^ak^rekqo]pbenopqjhaooukq#na@qp_d*

Jkseo^appanpd]jjaran*

=hpdkqcdjaraneokbpaj^appanpd]j&necdp&jks*

Ebpdaeilhaiajp]pekjeod]n`pkatlh]ej(ep#o]^]`e`a]*

Ebpdaeilhaiajp]pekjeoa]oupkatlh]ej(epi]u^a]ckk`e`a]*

J]iaol]_ao]nakjadkjgejccna]pe`a]))hap#o`kiknakbpdkoa

While some of this is clearly intended for humor, the majority is a good summation of

many Python philosophies. The remainder of this chapter highlights some specific principles

that are often cited within the Django community, but all professional Python programmers

should keep this text in mind and reference it often.

One important thing to keep in mind is that many of the lines in the Zen of Python are

subjective. For example, while “beautiful” may be better than “ugly,” definitions of “beauti-

ful” are plentiful and can vary as much as the people who provide them. Similarly, consider

notions of simplicity and complexity, practicality and purity; each developer will have a differ-

ent opinion on which side of the line a particular piece of code should be placed.

Django’s Interpretation of the MVC Pattern

One of the most common application architectures—as adopted by hobbyists and corporations

alike—is the Model-View- Controller (MVC) pattern, as it provides clean separation of tasks and

responsibilities among the prominent aspects of an application. Django only loosely follows

this model. A proper discussion should kick off with a quick overview of its components.

฀฀฀฀฀฀฀฀฀฀฀฀฀

฀฀฀฀฀฀฀฀฀

฀฀฀฀฀฀฀฀฀฀฀฀฀

1 dppl6++lnk`f]jck*_ki+lal).,+

CHAPTER 1 ฀ UNDERSTANDING DJANGO

While this pattern has proven very effective in many domains, Django’s authors weren’t

looking to conform to any form of pattern at the outset. They were simply interested in finding

the most effective way to develop software for the Web. After all, Django was built for the daily

needs of a working newspaper, where things have to happen very quickly if they’re to happen

at all. Ultimately, the separation of tasks into discrete groups serves a few different purposes.

฀฀฀฀฀฀฀฀฀฀฀฀฀฀฀฀฀฀

doesn’t need to make assumptions about completely unrelated parts of the application.

฀฀฀฀฀฀฀฀฀฀฀-

ferent view and controller layers may connect to a single model layer. This enables

variety of applications to share the same business logic and data, presenting it and

interacting with it in different ways, for different audiences.

฀฀

฀฀฀฀฀฀฀฀฀฀฀฀฀฀฀฀

work being performed. This specialization helps to curb frustration and fatigue, while

fostering creativity and excellence within each developer’s domain of specialty.

There are certainly other smaller benefits, but these are generally the main goals achieved

with the use of MVC. It’s interesting to note, however, that the only part of those benefits that

applies to any specific division in the MVC pattern is the ability to plug multiple applications

into a single model layer. The rest is just an arbitrary division based on common development

plans.

Django’s developers sought these same benefits, but with an emphasis on rapid development,

without worrying about creating a development pattern. After getting a set of tools that made sense

for their workflow, they ended up with what some have called a Model-Template- View (MTV)

pattern. However, there are really four primary code divisions in a Django application, which are

outlined next.

Model

Given the benefit of keeping models apart from the rest of the application, Django follows that

part of MVC to the letter. Django models provide easy access to an underlying data storage

mechanism, and can also encapsulate any core business logic, which must always remain in

effect, regardless of which application is using it.

Models exist independent of the rest of the system, and are designed to be used by any

application that has access to them. In fact, the database manipulation methods that are avail-

able on model instances can be utilized even from the interactive interpreter, without loading

a Web server or any application- specific logic.

Chapter 3 covers Django models in more detail, including how they’re defined and uti-

lized, how to include your own business logic and much more.

View

While they share a name with the original MVC definition, Django views have little else in

common with the traditional paradigm. Instead, they combine some of the traditional view’s

responsibility with the entirety of the controller’s tasks. A view accepts user input, including

simple requests for information; behaves according to the application’s interaction logic; and

returns a display that is suitable for users to access the data represented by models.

剩余311页未读，继续阅读

flyleafleaf

粉丝: 2
资源: 2

深入探索Django Web开发：Pro Django

Pro Django 2nd Marty Alchin 2013第二版

Pro django

Pro Django Apress

深入理解Django：Pro Django书籍精华

深入学习Django：Pro Django实战指南

深入理解Django：Marty Alchin的Pro Django探索

Pro Django(2nd) 无水印pdf

深化Python与Django技术：Pro Django 2008年高级指南

深化理解：Pro Django 2nd版揭示高级Python与Django技术

Pro Django：高级Python Web框架指南

最新资源