深化Python与Django：进阶开发宝典（第2版）

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

《Pro Django, 2nd Edition》是一本针对已有Python和Django基础读者的专业指南，由多年积累的经验作者编撰，旨在引领读者深入了解这两个领域的高级技术。书中涵盖了七个章节，从理解Django的基本原理到利用其高级功能进行深度开发。 **第一章：理解Django** 本章将引导读者熟悉Django框架的架构和设计理念，使他们对Django的核心概念有深入认识，包括MVC（Model-View-Controller）模式，以及Django如何处理Web请求和响应。 **第二章：Django是Python** 在这一章中，作者会强调Django与Python语言的紧密集成，讲解如何利用Python的强大功能来优化Django项目的开发过程，包括类、模块和库的使用。 **第三章：模型(Model)** 本章深入探讨Django中的数据模型设计，讲解如何创建数据库模型、关系模型以及迁移管理，让读者掌握数据持久化的高级技巧。 **第四章：URLs和视图(Views)** 通过学习如何配置URL路由和编写视图函数，读者将学会如何组织和控制网站的用户界面，实现复杂的逻辑处理。 **第五章：表单(Form)** 此章重点在于介绍Django的表单系统，包括验证、表单处理以及如何创建自定义表单组件，确保用户输入数据的安全性和有效性。 **第六章：模板(Templates)** 模板是Django页面渲染的关键，本章将深入讲解模板语言的语法、模板继承、模板过滤器和标签等，帮助读者构建动态网页。 **第七章：处理HTTP** 这一部分涵盖HTTP协议在Django中的应用，包括HTTP状态码、异常处理和中间件，让读者能更好地理解和应对Web服务的各种请求情况。 **第八章：后端协议(Backend Protocols)** 深入探讨Django与各种后端服务的交互，如RESTful API设计，以及如何使用Django实现更高效的数据交换。 **第九章：常用工具(Common Tools)** 介绍Django生态中的各种实用工具，如管理后台、静态文件处理、邮件发送和缓存机制，提升开发效率。 **第十章：协调应用程序(Coordinating Applications)** 讲解如何管理和协作多个Django应用，实现大型项目中模块化和组件化的开发策略。 **第十一章：增强应用程序(Enhancing Applications)** 最后一章提供关于如何优化应用性能、测试、部署和维护的建议，帮助读者将学到的知识应用到实际项目中。《Pro Django, 2nd Edition》是一部综合性的教程，不仅覆盖了基础知识，还深入探讨了Django框架的高级特性，为寻求进一步发展的开发者提供了丰富的实践指导和最佳实践案例。通过阅读本书，读者将不仅能提升技能，还能拓宽思路，为自己的项目带来更高的价值。

Chapter 2

Django Is Python

Django, like other frameworks, is built on an underlying programming language—in this case, Python—to do its work.

Many people who are new to Django are also new to Python, and Python’s natural-feeling syntax combined with

Django’s energy-saving features can make Django seem like it uses some kind of metalanguage, which isn’t the case.

A proper understanding of what can be done in Django must begin with the knowledge that Django is simply

Python, as are all of your applications. Anything that can be done in Python can be done in Django, which makes the

possibilities nearly limitless.

This also means that Django applications have access not only to the entire Python standard library, but also to an

immense collection of third-party libraries and utilities. Interfaces to some of these are provided along with Django itself,

so for many cases, the existing code and documentation will be sufficient to quickly get an application up and running.

Later in this book, some additional utilities are covered, along with some tips on how to integrate them into a

Django application. The possibilities aren’t limited to the options outlined in this book, so feel free to look around for

Python utilities that will help support your business plan, and use the techniques listed in this book to integrate them

into your application.

Though learning Python is beyond the scope of this book, Django uses some of its advanced features. In this

chapter, I’ll discuss many of those features to help you understand how Python can contribute to the goal of making

things easier for everyone.

How Python Builds Classes

Some of the most advanced Python techniques that Django relies on are related to how Python constructs its classes.

This process is often taken for granted by most developers—as well it should be—but since it’s at the heart of Django,

it forms the basis of this exploration.

When the Python interpreter encounters a class definition, it reads its contents just as it would any other

code. Python then creates a new namespace for the class and executes all the code within it, writing any variable

assignments to that new namespace. Class definitions generally contain variables, methods and other classes,

all of which are basically assignments to the namespace for the class. However, nearly any valid code is allowed here,

including printing to console output, writing to log files or even triggering GUI interaction.

Once the contents have finished executing, Python will have a class object that is ordinarily placed in the namespace

where it was defined (usually the global namespace for the module), where it is then passed around or called to create

instances of that class.

>>> class NormalClass:

... print('Loading NormalClass')

... spam = 'eggs'

... print('Done loading')

...

Loading NormalClass

CHAPTER 2 ■ DJANGO IS PYTHON

Done loading

>>> NormalClass

>>> NormalClass.spam

'eggs'

As you can see, code executes within the class definition, with any assigned variables showing up as class

attributes once the class is ready.

Building a Class Programmatically

The process described in the previous section is used for any source-declared class, but the way Python goes about it

offers the possibility of something far more interesting. Behind the scenes, details about the class declaration are sent

off to the built-in type object, which takes care of creating an appropriate Python object for the class. This happens

automatically, for every class, immediately when it finishes parsing the contents of the class declaration.

The constructor for type accepts three arguments, which represent the entire class declaration.

• name—The name provided for the class, as a string

• bases—A tuple of classes in the inheritance chain of the class; may be empty

• attrs—A dictionary of the class namespace

COMpatIBILItY: NeW-StYLe CLaSSeS IN pYthON 2

The process described in this section is true for new-style Python classes, a distinction introduced in Python 2.2

Old-style classes have been completely removed from Python 3, but if you're working with Python 2, you’ll need

to make sure to force new-style classes. To do so, simply make sure that the class inherits from the built-in

object type somewhere in its inheritance chain.

All the classes Django provides to be subclassed will already derive from object, so any further derivatives will

automatically be new-style classes, without any extra effort on your part. Still, it’s important to keep the difference

in mind, so that any custom classes your application may need will exhibit the behaviors outlined in this chapter.

Like any Python object, a new type can be instantiated at any time, from any block of code. This means that your

code can construct a new class based on data collected at runtime. The following code demonstrates a way to declare

a class at runtime, which is functionally equivalent to the example provided in the previous section.

>>> DynamicClass = type('DynamicClass', (), {'spam': 'eggs'})

>>> DynamicClass

>>> DynamicClass.spam

'eggs'

http://prodjango.com/new-style-classes/

CHAPTER 2 ■ DJANGO IS PYTHON

a WarNING aBOUt tYpe()

Using type() manually makes it easy to create classes with duplicate names, and even the module location can

be customized by providing a __module__ key in the dictionary in the attrs argument. Although these features

can be useful, as will be demonstrated later in this book, they can lead to problems with introspection.

You could reasonably have two different classes with the same name and module, but your code won’t be able to

tell the difference between them. This may not be a problem in some situations, but it’s something to be aware of.

Metaclasses Change It Up

type is actually a metaclass—a class that creates other classes—and what we’ve been engaging in is called

metaprogramming.

In essence, metaprogramming creates or modifies code at runtime rather than at programming

time. Python allows you to customize this process by allowing a class to define a different metaclass to perform its work.

If a class definition includes a separate class for its metaclass option, that metaclass will be called to create

the class, rather than the built-in type object. This allows your code to read, modify or even completely replace

the declared class to further customize its functionality. The metaclass option could technically be given any

valid Python callable, but most metaclasses are subclasses of type. The metaclass receives the new class as its first

argument and provides access to the class object along with the details regarding its declaration.

To help illustrate how the metaclass arguments are derived from a class definition, take the following code as

an example.

>>> class MetaClass(type):

... def __init__(cls, name, bases, attrs):

... print('Defining %s' % cls)

... print('Name: %s' % name)

... print('Bases: %s' % (bases,))

... print('Attributes:')

... for (name, value) in attrs.items():

... print(' %s: %r' % (name, value))

...

>>> class RealClass(object, metaclass=MetaClass):

... spam = 'eggs'

...

Defining <class '__main__.RealClass'>

Name: RealClass

Bases: (<class 'object'>,)

Attributes:

spam: 'eggs'

__module__: '__main__'

__qualname__: 'RealClass'

>>> RealClass

Notice that the class wasn’t instantiated at any time; the simple act of creating the class triggered execution of the

metaclass. Notice __module__ in the list of attributes: this attribute is a standard part of all Python classes.

http://prodjango.com/metaprogramming/

CHAPTER 2 ■ DJANGO IS PYTHON

While this example uses the __init__ method to perform special processing on the newly created class, there

is another, somewhat more powerful method called __new__, with the potential for a different set of possibilities.

As described in later chapters, Django uses __new__ when configuring many of its classes.

COMpatIBILItY: MetaCLaSSeS IN pYthON 2

Python 3 introduced the ability to pass arguments into a class definition, as shown here with the metaclass

option. In Python 2, metaclasses were assigned to a class variable named __metaclass__. The effect is identical

in both versions; it’s only a syntax change.

Using a Base Class with a Metaclass

Metaclasses can be quite useful, but the metaclass option is an implementation detail, which shouldn’t need to be

part of the process when defining classes. Another problem is that while each class gets processed by the metaclass,

they don’t inherit from any concrete class. This means that any additional functionality, such as common methods or

attributes, would have to be provided during metaclass processing in order to be of any use.

With a bit of care, a concrete Python class can use a metaclass to solve both of these problems. Since

subclasses inherit attributes from their parents, the metaclass option is automatically provided for all subclasses

of a class that defines it. This is a simple, effective way to provide metaclass processing for arbitrary classes, without

requiring that each class define the metaclass option. Following the example from the previous section, look what

happens when we subclass RealClass.

>>> class SubClass(RealClass): # Notice there's no metaclass here.

... pass

...

Defining <class '__main__.SubClass'>

Name: SubClass

Bases: (<class '__main__.RealClass'>,)

Attributes:

__module__: '__main__'

Notice how the subclass here doesn’t have to worry about the fact that there’s a metaclass in use behind the

scenes. By just specifying a base class, it inherits all the benefits. Django uses this behavior to implement one of its

most prominent features, described in the next section.

Declarative Syntax

Some of Django’s more prominent tools feature a “declarative syntax” that is simple to read, write and understand.

This syntax is designed to make minimize “boilerplate” repetitive syntax and provide elegant, readable code.

For example, here’s what a typical Django model and more might look like:

class Contact(models.Model):

"""

Contact information provided when sending messages to the owner of the site.

"""

name = models.CharField(max_length=255)

email = models.EmailField()

CHAPTER 2 ■ DJANGO IS PYTHON

This declarative syntax has become an identifying feature of Django code, so many third-party applications that

supply additional frameworks are written to use a syntax similar to that of Django itself. This helps developers easily

understand and utilize new code by making it all feel more cohesive. Once you understand how to create a class using

declarative syntax, you’ll easily be able to create classes using many Django features, both official and community-provided.

Looking at declarative syntax on its own will demonstrate how easy it is to create an entirely new framework for Django

that fits with this pattern. Using declarative syntax in your own code will help you and your colleagues more easily adapt to

the code, ensuring greater productivity. After all, developer efficiency is a primary goal of Django and of Python itself.

While the next few sections describe declarative syntax in general, the examples shown are for Django’s

object-relational mapper (ORM), detailed in Chapter 3.

Centralized Access

Typically, a package will supply a single module from which applications can access all the necessary utilities. This

module may pull the individual classes and functions from elsewhere in its tree, so they can still use maintainable

namespaces, but they will all be collected into one central location.

from django.db import models

Once imported, this module provides at least one class intended as the base class for subclasses based on the

framework. Additional classes are provided to be used as attributes of the new subclass. Together, these objects will

combine to control how the new class will work.

The Base Class

Each feature starts with at least one base class. There may be more, depending on the needs of the framework, but at

least one will always be required in order to make this syntax possible. Without it, every class you ask your users to define

will have to include a metaclass explicitly, which is an implementation detail most users shouldn’t need to know about.

class Contact(models.Model):

In addition to inspecting the defined attributes, this base class will provide a set of methods and attributes that

the subclass will automatically inherit. Like any other class, it can be as simple or complex as necessary to provide

whatever features the framework requires.

Attribute Classes

The module supplying the base class will also provide a set of classes to be instantiated, often with optional arguments

to customize their behavior and assigned as attributes of a new class.

class Contact(models.Model):

name = models.CharField(max_length=255)

email = models.EmailField()

The features these objects provide will vary greatly across frameworks, and some may behave quite differently

from a standard attribute. Often they will combine with the metaclass to provide some additional, behind-the-scenes

functionality beyond simply assigning an attribute. Options to these attribute classes are usually read by the metaclass

when creating this extra functionality.

剩余289页未读，继续阅读

li2013ndsc

粉丝: 0
资源: 1

深化Python与Django：进阶开发宝典（第2版）

The Definitive Guide to Django 2nd Edition

Pro Django(2nd) 无水印pdf

Pro Django 2nd Marty Alchin 2013第二版

Django 2nd Edition：Web开发权威指南

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

Apress - Practical Django Projects 2nd Edition

Apress - Practical Django Projects 2nd Edition 2009

Apress - Practical Django Projects 2nd Edition.pdf

Apress - Practical Django Projects 2nd Edition源代码

Apress.Pro.Django.2nd.Edition.Jul.2013

最新资源