Pro Django：2009技术专著，权威英文指南

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

"《Pro Django》是一本由Marty Alchin撰写的高级Python和Django技术书籍，专为对Web开发感兴趣的IT专业人士设计。这本书在2009年出版，是针对Django框架的深入指南，适合那些希望提升自己在Django平台上构建复杂、高效应用能力的读者。作为一本国外英文资料，它提供了详尽的教程和实践案例，涵盖了Django的核心概念、模板系统、URL路由、模型管理、表单处理、认证授权以及高级主题，如Ajax、数据库操作、测试驱动开发等。作者Marty Alchin以其清晰的解释和实用的策略，帮助读者理解并掌握Django的最佳实践。版权方面，所有内容未经版权所有者Marty Alchin和出版社Apress事先书面许可，不得任何形式复制或传输，包括影印、录音或通过任何信息存储和检索系统。本书的纸质版ISBN-13为978-1-4302-1047-4，电子版则为978-1-4302-1048-1，体现了其专业性和权威性。在编排上，该书不仅注重技术深度，也考虑到了版权法规，对于商标名的使用遵循了编辑规范，如提及Java™时，强调了其为Sun Microsystems, Inc.的商标，尽管并未获得官方背书。本书的领导编辑是Steve Anglin，技术评审人员包括Jacob Kaplan-Moss和George Vilches，而Clay Andres、Steve Anglin和Mark Bec则构成了编辑委员会，确保了内容的质量和一致性。《Pro Django》是一本不可或缺的参考资源，无论是初学者还是经验丰富的开发者，都可以从中获取关于Django框架的深入理解和实践经验，助力他们在IT领域取得更大的成就。"

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

name_less

粉丝: 17
资源: 8

Pro Django：2009技术专著，权威英文指南

Pro Django(2nd) 无水印pdf

Pro Django, 2nd Edition.pdf

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

Scaling-Instagram.pdf

物质的分离和提纯详解共37页.pdf.zip

django 2013 新书

python-bootcamp-web:python pro bootcamp在线课程的项目

Kindle Computer Science other.rar

自学前端javaPythonPHPps等视频教程链接.rar

Python-100-Days (附源码).zip

最新资源