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

需积分: 10 186 浏览量更新于2024-07-17 收藏 3.29MB PDF 举报

"《Pro Django, 第2版》是一本深入探讨Python和Django框架的高级指南，作者结合七年来的专业知识，旨在帮助读者在对这两种技术有一定了解的基础上，进一步提升技能。本书不仅详细介绍了Django的基本构建块，如模型、URLs与视图、表单、模板、处理HTTP请求、后端协议、常用工具、应用程序协调以及应用增强，还着重强调了在编码过程中思维过程的重要性。作者认为，仅仅编写代码是不够的，程序员需要深思熟虑如何设计功能、实施方法、选择依赖软件以及为未来扩展预留接口。Django框架已经预先做出了许多决策，其提供的工具受到这些决策的影响。通过理解和采纳Django的设计哲学，开发者不仅能保持一致性，还能在自己的项目中实现更高效和有远见的开发。章节1到11分别涵盖了Django的核心概念，如理解Django的底层逻辑，确认它与Python的关系，模型的定义和管理，路由和视图的组织，表单的设计，模板语言的使用，HTTP请求的处理方式，以及如何处理不同的后端通信协议。此外，书中还讨论了诸如共享工具、不同应用程序之间的协作以及如何改进现有应用等实用技巧。对于那些来自其他编程背景的读者，章节中的某些理念可能显得新颖，但它们至关重要。所有使用Python和Django的程序员都应该掌握框架的工作原理及其原则，以便在其他项目中灵活运用。本书可能会需要多次阅读和参考，特别是当你准备与其他开发者交流时，对内容的深入理解是必不可少的。《Pro Django, 第2版》是一本帮助读者深化对Python和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.

www.allitebooks.com

剩余289页未读，继续阅读

恒云客

粉丝: 36
资源: 41

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

Pro Django

Pro Django(2nd) 无水印pdf

pro_django(有道文档翻译).zip

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

Apress - Practical Django Projects 2nd Edition.pdf

Head First Python, 2nd Edition.pdf

Programming Google App Engine, 2nd Edition.pdf

（备份）Python Crash Course, 2nd Edition.pdf

Apress.Practical.Django.Projects.2nd.Edition

Django中文文档.pdf

最新资源