The Django Book

Streamlining Function Imports

Yfphr6 <a href=”http://wkchavkykyhr.com/“>wkchavkykyhr</a>, [url=http://muokhwblpfjl.com/]muokhwblpfjl[/url], [link=http://ploxqieojkeb.com/]ploxqieojkeb[/link], http://xhutfvdzimfx.com/

Consider this URLconf, which builds on the example in Chapter 3:

看下这个 URLconf，它是建立在第三章的例�上:

from django.conf.urls.defaults import *
from mysite.views import current_datetime, hours_ahead, hours_behind, now_in_chicago, now_in_london

urlpatterns = patterns('',
    (r'^now/$', current_datetime),
    (r'^now/plus(\d{1,2})hours/$', hours_ahead),
    (r'^now/minus(\d{1,2})hours/$', hours_behind),
    (r'^now/in_chicago/$', now_in_chicago),
    (r'^now/in_london/$', now_in_london),
)

As explained in Chapter 3, each entry in the URLconf includes its associated view function, passed directly as a function object. This means its necessary to import the view functions at the top of the module.

正如第三章中所解释的，在 URLconf 中的�一个入�包括了它所�系的视图函数，直接传入了一个函数对象。这就�味�需�在模�开始处导入视图函数。

But as a Django application grows in complexity, its URLconf grows, too, and keeping those imports can be tedious to manage. (For each new view function, you have to remember to import it, and the import statement tends to get overly long if you use this approach.) Its possible to avoid that tedium by importing the views module itself. This example URLconf is equivalent to the previous one:

但�� Django 应用�得��，它的 URLconf 也在增长，并且维护这些导入�能使得管��麻烦。(对�个新的view函数，你�得�记��导入它，并且如果采用这�方法导入语�将�得相当长。)有�能通过导入 views 模�本身���这个麻烦。这个 URLconf 示例�上一个是等价的:

from django.conf.urls.defaults import *
from mysite import views

urlpatterns = patterns('',
    (r'^now/$', views.current_datetime),
    (r'^now/plus(\d{1,2})hours/$', views.hours_ahead),
    (r'^now/minus(\d{1,2})hours/$', views.hours_behind),
    (r'^now/in_chicago/$', views.now_in_chicago),
    (r'^now/in_london/$', views.now_in_london),
)

Django offers another way of specifying the view function for a particular pattern in the URLconf: you can pass a string containing the module name and function name rather than the function object itself. Continuing the ongoing example:

Django 还�供了�一�方法�以在 URLconf 中为�个特别的模�指定视图函数：你�以传入一个包�模��和函数�的字符串，而�是函数对象本身。继续示例:

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^now/$', 'mysite.views.current_datetime'),
    (r'^now/plus(\d{1,2})hours/$', 'mysite.views.hours_ahead'),
    (r'^now/minus(\d{1,2})hours/$', 'mysite.views.hours_behind'),
    (r'^now/in_chicago/$', 'mysite.views.now_in_chicago'),
    (r'^now/in_london/$', 'mysite.views.now_in_london'),
)

(Note the quotes around the view names. Were using 'mysite.views.current_datetime' with quotes instead of mysite.views.current_datetime .)

(注�视图���的引�。应该使用带引�的 'mysite.views.current_datetime' 而�是 mysite.views.current_datetime 。)

Using this technique, its no longer necessary to import the view functions; Django automatically imports the appropriate view function the first time its needed, according to the string describing the name and path of the view function.

使用这个技术，就�必导入视图函数了；Django 会在第一次需�它时导入�适的视图函数，根�字符串所�述的视图函数的�字和路径。

A further shortcut you can take when using the string technique is to factor out a common view prefix. In our URLconf example, each of the view strings starts with 'mysite.views' , which is redundant to type. We can factor out that common prefix and pass it as the first argument to patterns() , like this:

当使用字符串技术时，你�以采用更简化的方�：��出一个公共视图�缀。在我们的 URLconf 例�中，�一个视图字符串都是以 'mysite.views' 开始的，造�过多的输入。我们�以��出公共�缀然�把它作为第一个�数传给 patterns() ，如:

from django.conf.urls.defaults import *

urlpatterns = patterns('mysite.views',
    (r'^now/$', 'current_datetime'),
    (r'^now/plus(\d{1,2})hours/$', 'hours_ahead'),
    (r'^now/minus(\d{1,2})hours/$', 'hours_behind'),
    (r'^now/in_chicago/$', 'now_in_chicago'),
    (r'^now/in_london/$', 'now_in_london'),
)

Note that you dont put a trailing dot ("." ) in the prefix, nor do you put a leading dot in the view strings. Django puts those in automatically.

注�既��在�缀��跟�一个点�("." )，也��在视图字符串��放一个点�。 Django 会自动处�它们。

With these two approaches in mind, which is better? It really depends on your personal coding style and needs.

牢记这两�方法，哪�更好一些呢？这�决于你的个人编�习惯和需�。

Advantages of the string approach are as follows:

UNF5vX <a href=”http://hdugwlkorxzw.com/“>hdugwlkorxzw</a>, [url=http://sbppygxqjdcj.com/]sbppygxqjdcj[/url], [link=http://icxfehixtpuo.com/]icxfehixtpuo[/link], http://tmihfbbxxydh.com/

• Its more compact, because it doesnt require you to import the view functions.

N9gqns <a href=”http://wteejridtwke.com/“>wteejridtwke</a>, [url=http://lxotonbmgclb.com/]lxotonbmgclb[/url], [link=http://hkhsettjexoq.com/]hkhsettjexoq[/link], http://dlapxtivyork.com/

• It results in more readable and manageable URLconfs if your view functions are spread across several different Python modules.

• 如果你的视图函数存在于几个ä¸�å�Œçš„ Python 模å�—çš„è¯�，它å�¯ä»¥ä½¿å¾— URLconf 更易读和管ç�†ã€‚

Advantages of the function object approach are as follows:

WdAon8 <a href=”http://gnuhdlcakrdi.com/“>gnuhdlcakrdi</a>, [url=http://mkbdhjkqvlqt.com/]mkbdhjkqvlqt[/url], [link=http://rdpcyyxxithz.com/]rdpcyyxxithz[/link], http://rsbyearxigne.com/

• It allows for easy wrapping of view functions. See the section Wrapping View Functions later in this chapter.

• 更容易对视图函数进行包装(wrap)。å�‚è§�本章å�Žé�¢çš„《包装视图函数》一节。

• Its more Pythonic that is, its more in line with Python traditions, such as passing functions as objects.

• æ›´ Pythonic，更符å�ˆ Python 的传统，如把函数当æˆ�对象传递。

Both approaches are valid, and you can even mix them within the same URLconf. The choice is yours.

两个方法都是有效的，甚至你�以在�一个 URLconf 中混用它们。决定�在你。

Using Multiple View Prefixes

使用多个视图�缀

In practice, if you use the string technique, youll probably end up mixing views to the point where the views in your URLconf wont have a common prefix. However, you can still take advantage of the view prefix shortcut to remove duplication. Just add multiple patterns() objects together, like this:

在实践中，如果你使用字符串技术，特别是当你的 URLconf 中没有一个公共�缀时，你最终�能混�视图。然而，你�然�以利用视图�缀的简便方���少��。��增加多个 patterns() 对象，象这样:

Old:

旧的:

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^/?$', 'mysite.views.archive_index'),
    (r'^(\d{4})/([a-z]{3})/$', 'mysite.views.archive_month'),
    (r'^tag/(\w+)/$', 'weblog.views.tag'),
)

New:

æ–°çš„:

from django.conf.urls.defaults import *

urlpatterns = patterns('mysite.views',
    (r'^/?$', 'archive_index'),
    (r'^(\d{4})/([a-z]{3})/$', 'archive_month'),
)

urlpatterns += patterns('weblog.views',
    (r'^tag/(\w+)/$', 'tag'),
)

All the framework cares about is that theres a module-level variable called urlpatterns . This variable can be constructed dynamically, as we do in this example.

整个框架关注的是存在一个�为 urlpatterns 的模�级别的��。这个���以动�构建，正如本例中我们所�的一样。

Special-Casing URLs in Debug Mode

调试模�中的特例

Speaking of constructing urlpatterns dynamically, you might want to take advantage of this technique to alter your URLconfs behavior while in Djangos debug mode. To do this, just check the value of the DEBUG setting at runtime, like so:

当谈到动�构建 urlpatterns 时，你�能想利用这一技术，在 Django 的调试模�时，�修改 URLconf 的行为。为了�到这一点，��在�行时检查 DEBUG �置项的值��，如:

from django.conf.urls.defaults import*
from django.conf import settings

urlpatterns = patterns('',
    (r'^$', 'mysite.views.homepage'),
    (r'^(\d{4})/([a-z]{3})/$', 'mysite.views.archive_month'),
)

if settings.DEBUG:
    urlpatterns += patterns('',
        (r'^debuginfo$', 'mysite.views.debug'),
    )

In this example, the URL /debuginfo/ will only be available if your DEBUG setting is set to True .

在这个例�中，URL /debuginfo/ 将�有在你的 DEBUG �置项设为 True 时�有效。

Using Named Groups

使用命�组

In all of our URLconf examples so far, weve used simple, non-named regular expression groups that is, we put parentheses around parts of the URL we wanted to capture, and Django passes that captured text to the view function as a positional argument. In more advanced usage, its possible to use named regular expression groups to capture URL bits and pass them as keyword arguments to a view.

到目�为止，在所有 URLconf 例�中，我们使用的很简�，� 无命� 正则表达�组，在我们想��获的URL部分上加上�括�，Django 会将�获的文本作为�置�数传递给视图函数。在更高级的用法中，还�以使用 命� 正则表达�组��获URL，并且将其作为 关键字 �数传给视图。

Keyword Arguments vs. Positional Arguments

关键字�数 对比 �置�数

A Python function can be called using keyword arguments or positional arguments and, in some cases, both at the same time. In a keyword argument call, you specify the names of the arguments along with the values youre passing. In a positional argument call, you simply pass the arguments without explicitly specifying which argument matches which value; the association is implicit in the arguments order.

一个 Python 函数�以使用关键字�数或�置�数�调用，在�些情况下，�以�时进行使用。在关键字�数调用中，你�指定�数的�字和传入的值。在�置�数调用中，你�需传入�数，�需�明确指明哪个�数与哪个值对应，它们的对应关系��在�数的顺�中。

For example, consider this simple function:

fozlR6 <a href=”http://alwpeqonzzpd.com/“>alwpeqonzzpd</a>, [url=http://eoblepdgxmzt.com/]eoblepdgxmzt[/url], [link=http://azkrzziaumle.com/]azkrzziaumle[/link], http://gfkmondejkch.com/

def sell(item, price, quantity):
    print "Selling %s unit(s) of %s at %s" % (quantity, item, price)

To call it with positional arguments, you specify the arguments in the order in which theyre listed in the function definition:

为了使用�置�数�调用它，你�按照在函数定义中的顺��指定�数。

sell('Socks', '$2.50', 6)

To call it with keyword arguments, you specify the names of the arguments along with the values. The following statements are equivalent:

为了使用关键字�数�调用它，你�指定�数�和值。下�的语�是等价的:

sell(item='Socks', price='$2.50', quantity=6)
sell(item='Socks', quantity=6, price='$2.50')
sell(price='$2.50', item='Socks', quantity=6)
sell(price='$2.50', quantity=6, item='Socks')
sell(quantity=6, item='Socks', price='$2.50')
sell(quantity=6, price='$2.50', item='Socks')

Finally, you can mix keyword and positional arguments, as long as all positional arguments are listed before keyword arguments. The following statements are equivalent to the previous examples:

最�，你�以混�关键字和�置�数，��所有的�置�数列在关键字�数之�。下�的语�与��的例�是等价:

sell('Socks', '$2.50', quantity=6)
sell('Socks', price='$2.50', quantity=6)
sell('Socks', quantity=6, price='$2.50')

In Python regular expressions, the syntax for named regular expression groups is (?P<name>pattern) , where name is the name of the group and pattern is some pattern to match.

在 Python 正则表达�中，命�的正则表达�组的语法是 (?P<name>pattern) ，这里 name 是组的�字，而 pattern 是匹�的�个模�。

Heres an example URLconf that uses non-named groups:

下�是一个使用无�组的 URLconf 的例�:

from django.conf.urls.defaults import *
from mysite import views

urlpatterns = patterns('',
    (r'^articles/(\d{4})/$', views.year_archive),
    (r'^articles/(\d{4})/(\d{2})/$', views.month_archive),
)

Heres the same URLconf, rewritten to use named groups:

ZNpmIL <a href=”http://qucosvxmznkl.com/“>qucosvxmznkl</a>, [url=http://yjdxzjajhrsz.com/]yjdxzjajhrsz[/url], [link=http://zreyikrpzidz.com/]zreyikrpzidz[/link], http://esdpsbeowseu.com/

from django.conf.urls.defaults import *
from mysite import views

urlpatterns = patterns('',
    (r'^articles/(?P<year>\d{4})/$', views.year_archive),
    (r'^articles/(?P<year>\d{4})/(?P<month>\d{2})/$', views.month_archive),
)

This accomplishes exactly the same thing as the previous example, with one subtle difference: the captured values are passed to view functions as keyword arguments rather than positional arguments.

这段代�和��的功能完全一样，�有一个细微的差别：把��的值用命��数的方� 传递给视图函数，而�是用按顺�的匿��数的方�。

For example, with non-named groups, a request to /articles/2006/03/ would result in a function call equivalent to this:

1tKNw5 <a href=”http://sdstpbzgmmbn.com/“>sdstpbzgmmbn</a>, [url=http://cvnjgcutyrcm.com/]cvnjgcutyrcm[/url], [link=http://reeabkflkcju.com/]reeabkflkcju[/link], http://bsppctebirpy.com/

month_archive(request, '2006', '03')

With named groups, though, the same request would result in this function call:

而带命�组，�样的请求就是这样的函数调用：

month_archive(request, year='2006', month='03')

In practice, using named groups makes your URLconfs slightly more explicit and less prone to argument-order bugs and you can reorder the arguments in your views function definitions. Following the preceding example, if we wanted to change the URLs to include the month before the year, and we were using non-named groups, wed have to remember to change the order of arguments in the month_archive view. If we were using named groups, changing the order of the captured parameters in the URL would have no effect on the view.

使用命�组�以让你的URLconfs更加清晰，�少�数次��能�混的潜在BUG，还�以 让你在函数定义中对�数�新排�。接�上�这个例�，如果我们想修改URL把月份放到 年份的 �� ，而�使用命�组的�，我们就�得�去修改视图 month_archive 的�数次�。如果我们使用命�组的�，修改URL里���数的次�对视图没有影�。

Of course, the benefits of named groups come at the cost of brevity; some developers find the named-group syntax ugly and too verbose. Still, another advantage of named groups is readability, especially by those who arent intimately familiar with regular expressions or your particular Django application. Its easier to see whats happening, at a glance, in a URLconf that uses named groups.

当然，命�组的代价就是失去了简�性：一些开�者觉得命�组的语法丑陋和显得冗余。 命�组的�一个好处就是�读性强，特别是熟悉正则表达�或自己开�的Django 应用的开�者。看一眼URLconf里的这些命�组就知�这是干什么用的了。

Understanding the Matching/Grouping Algorithm

�解匹�/分组算法

A caveat with using named groups in a URLconf is that a single URLconf pattern cannot contain both named and non-named groups. If you do this, Django wont throw any errors, but youll probably find that your URLs arent matching as you expect. Specifically, heres the algorithm the URLconf parser follows, with respect to named groups vs. non-named groups in a regular expression:

BsL55I <a href=”http://tasqioamrqly.com/“>tasqioamrqly</a>, [url=http://sftafnnqcumd.com/]sftafnnqcumd[/url], [link=http://ozgzxececcmx.com/]ozgzxececcmx[/link], http://uyetccdkpzdx.com/

• If there are any named arguments, it will use those, ignoring non-named arguments.

• 如果有任何命å��的组，Django会忽略é�žå‘½å��组而直接使用命å��组。

• Otherwise, it will pass all non-named arguments as positional arguments.

• å�¦åˆ™ï¼ŒDjango会把所有é�žå‘½å��组以ä½�ç½®å�‚æ•°çš„å½¢å¼�传递。

• In both cases, it will pass any extra options as keyword arguments. See the next section for more information.

4CzvPf <a href=”http://bejuaosszhqg.com/“>bejuaosszhqg</a>, [url=http://mustddehuwps.com/]mustddehuwps[/url], [link=http://ogxgzaaxzdxl.com/]ogxgzaaxzdxl[/link], http://freqjzbnxehd.com/

Passing Extra Options to View Functions

3eZTaA <a href=”http://nmizqdrskmhq.com/“>nmizqdrskmhq</a>, [url=http://nsvgonwjlhyi.com/]nsvgonwjlhyi[/url], [link=http://osnzcwpdayxd.com/]osnzcwpdayxd[/link], http://posghywqmixc.com/

Sometimes youll find yourself writing view functions that are quite similar, with only a few small differences. For example, say you have two views whose contents are identical except for the template they use:

有时你会�现你写的视图函数是�分类似的，�有一点点的��。比如说，你有两个视图，它们的内容是一致的，除了它们所用的模��太一样：

# urls.py

from django.conf.urls.defaults import *
from mysite import views

urlpatterns = patterns('',
    (r'^foo/$', views.foo_view),
    (r'^bar/$', views.bar_view),
)

# views.py

from django.shortcuts import render_to_response
from mysite.models import MyModel

def foo_view(request):
    m_list = MyModel.objects.filter(is_new=True)
    return render_to_response('template1.html', {'m_list': m_list})

def bar_view(request):
    m_list = MyModel.objects.filter(is_new=True)
    return render_to_response('template2.html', {'m_list': m_list})

Were repeating ourselves in this code, and thats inelegant. At first, you may think to remove the redundancy by using the same view for both URLs, putting parentheses around the URL to capture it, and checking the URL within the view to determine the template, like so:

我们在这代�里��了��的工作，�够简练。起�你�能会想，通过对两个URL都试用�样的视图，在URL中使用括���请求，然�在视图中检查并决定使用哪个模��去除代�的冗余，就�这样：

# urls.py

from django.conf.urls.defaults import *
from mysite import views

urlpatterns = patterns('',
    (r'^(foo)/$', views.foobar_view),
    (r'^(bar)/$', views.foobar_view),
)

# views.py

from django.shortcuts import render_to_response
from mysite.models import MyModel

def foobar_view(request, url):
    m_list = MyModel.objects.filter(is_new=True)
    if url == 'foo':
        template_name = 'template1.html'
    elif url == 'bar':
        template_name = 'template2.html'
    return render_to_response(template_name, {'m_list': m_list})

The problem with that solution, though, is that it couples your URLs to your code. If you decide to rename /foo/ to /fooey/ , youll have to remember to change the view code.

这�解决方案的问题还是�缺点，就是把你的URL耦�进你的代�里�了。如果你打算把 /foo/ 改� /fooey/ 的�，那么你就得记��去改�视图里�的代�。

The elegant solution involves an optional URLconf parameter. Each pattern in a URLconf may include a third item: a dictionary of keyword arguments to pass to the view function.

优雅的解决方法：使用一个�外的URLconf�数。一个URLconf里�的�一个模��以包�第三个数�：一个传到视图函数中的关键字�数的字典。

With this in mind, we can rewrite our ongoing example like this:

有了这个概念以�，我们就�以把我们现在的例�改写�这样：

# urls.py

from django.conf.urls.defaults import *
from mysite import views

urlpatterns = patterns('',
    (r'^foo/$', views.foobar_view, {'template_name': 'template1.html'}),
    (r'^bar/$', views.foobar_view, {'template_name': 'template2.html'}),
)

# views.py

from django.shortcuts import render_to_response
from mysite.models import MyModel

def foobar_view(request, template_name):
    m_list = MyModel.objects.filter(is_new=True)
    return render_to_response(template_name, {'m_list': m_list})

As you can see, the URLconf in this example specifies template_name in the URLconf. The view function treats it as just another parameter.

如你所�，这个例�中，URLconf指定了 template_name 。而视图函数则会把它处���一个�数而已。

This extra URLconf options technique is a nice way of sending additional information to your view functions with minimal fuss. As such, its used by a couple of Djangos bundled applications, most notably its generic views system, which we cover in Chapter 9.

这�外的URLconf�数的技术以最少的麻烦给你�供了�视图函数传递�外信�的一个好方法。正因如此，这技术已被很多Django的�绑应用使用，其中以我们将会在第9章讨论的通用视图系统最为明显。

The following sections contain a couple of ideas on how you can use the extra URLconf options technique in your own projects.

下�的几节里�有一些关于你�以怎样把�外URLconf�数技术应用到你自己的工程的建议。

/mydata/jan/01/
/mydata/jan/02/
/mydata/jan/03/
# ...
/mydata/dec/30/
/mydata/dec/31/

urlpatterns = patterns('',
    (r'^mydata/(?P<month>\w{3})/(?P<day>\d\d)/$', views.my_view),
)

def my_view(request, month, day):
    # ....

urlpatterns = patterns('',
    (r'^mydata/birthday/$', views.my_view, {'month': 'jan', 'day': '06'}),
    (r'^mydata/(?P<month>\w{3})/(?P<day>\d\d)/$', views.my_view),
)

def say_hello(person_name):
    print 'Hello, %s' % person_name

def say_goodbye(person_name):
    print 'Goodbye, %s' % person_name

def greet(person_name, greeting):
    print '%s, %s' % (greeting, person_name)

# urls.py

from django.conf.urls.defaults import *
from mysite import views

urlpatterns = patterns('',
    (r'^events/$', views.event_list),
    (r'^blog/entries/$', views.entry_list),
)

# views.py

from django.shortcuts import render_to_response
from mysite.models import Event, BlogEntry

def event_list(request):
    obj_list = Event.objects.all()
    return render_to_response('mysite/event_list.html', {'event_list': obj_list})

def entry_list(request):
    obj_list = BlogEntry.objects.all()
    return render_to_response('mysite/blogentry_list.html', {'entry_list': obj_list})

# urls.py

from django.conf.urls.defaults import *
from mysite import models, views

urlpatterns = patterns('',
    (r'^events/$', views.object_list, {'model': models.Event}),
    (r'^blog/entries/$', views.object_list, {'model': models.BlogEntry}),
)

# views.py

from django.shortcuts import render_to_response

def object_list(request, model):
    obj_list = model.objects.all()
    template_name = 'mysite/%s_list.html' % model.__name__.lower()
    return render_to_response(template_name, {'object_list': obj_list})

def my_view(request, template_name):
    var = do_something()
    return render_to_response(template_name, {'var': var})

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^mydata/(?P<id>\d+)/$', views.my_view, {'id': 3}),
)

Using Default View Arguments

使用缺�视图�数

Another convenient trick is to specify default parameters for a views arguments. This tells the view which value to use for a parameter by default if none is specified.

�外一个方便的特性是你�以给一个视图指定默认的�数。这样，当没有给这个�数赋值的时候将会使用默认的值。

Heres an example:

请看例�：

# urls.py

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^blog/$', views.page),
    (r'^blog/page(?P<num>\d+)/$', views.page),
)

# views.py

def page(request, num="1"):
    # Output the appropriate page of blog entries, according to num.
    # ...

Here, both URL patterns point to the same view views.page but the first pattern doesnt capture anything from the URL. If the first pattern matches, the page() function will use its default argument for num , "1" . If the second pattern matches, page() will use whatever num value was captured by the regular expression.

在这里，两个URL表达�都指�了�一个视图 views.page ，但是第一个表达�没有传递任何�数。如果匹�到了第一个样�， page() 函数将会对�数 num 使用默认值 "1" ，如果第二个表达�匹��功， page() 函数将使用正则表达�传递过�的num的值。

Its common to use this technique in conjunction with configuration options, as explained earlier. This example makes a slight improvement to the example in the Giving a View Configuration Options section by providing a default value for template_name :

就���解释的一样，这�技术与�置选项的�用是很普�的。以下这个例�比�供视图�置选项一节中的例�有些许的改进。它为 template_name �供了一个默认值：

def my_view(request, template_name='mysite/my_view.html'):
    var = do_something()
    return render_to_response(template_name, {'var': var})

Special-Casing Views

特殊情况下的视图

Sometimes youll have a pattern in your URLconf that handles a large set of URLs, but youll need to special-case one of them. In this case, take advantage of the linear way a URLconf is processed and put the special case first.

有时你有一个模��处�在你的URLconf中的一系列URL，但是有时候需�特别处�其中的�个URL。在这�情况下，�使用将URLconf中把特殊情况放在首�的线性处�方� 。

For example, the add an object pages in Djangos admin site are represented by this URLconf line:

例如，Django的admin站点中添加一个对象页�是如下�置的：

urlpatterns = patterns('',
    # ...
    ('^([^/]+)/([^/]+)/add/$', 'django.contrib.admin.views.main.add_stage'),
    # ...
)

This matches URLs such as /myblog/entries/add/ and /auth/groups/add/ . However, the add page for a user object (/auth/user/add/ ) is a special case it doesnt display all of the form fields, it displays two password fields, and so forth. We could solve this problem by special-casing in the view, like so:

这将匹�� /myblog/entries/add/ 和 /auth/groups/add/ 这样的URL 。然而，对于用户对象的添加页�（ /auth/user/add/ ）是个特殊情况，因为它�会显示所有的表�域，它显示两个密�域等等。我们 �以 在视图中特别指出以解决这�情况：

def add_stage(request, app_label, model_name):
    if app_label == 'auth' and model_name == 'user':
        # do special-case code
    else:
        # do normal code

but thats inelegant for a reason weve touched on multiple times in this chapter: it puts URL logic in the view. As a more elegant solution, we can take advantage of the fact that URLconfs are processed in order from top to bottom:

�过，就如我们多次在这章�到的，这样�并�优雅：因为它把URL逻辑放在了视图中。更优雅的解决方法是，我们�利用URLconf从顶�下的解�顺�这个特点：

urlpatterns = patterns('',
    # ...
    ('^auth/user/add/$', 'django.contrib.admin.views.auth.user_add_stage'),
    ('^([^/]+)/([^/]+)/add/$', 'django.contrib.admin.views.main.add_stage'),
    # ...
)

With this in place, a request to /auth/user/add/ will be handled by the user_add_stage view. Although that URL matches the second pattern, it matches the top one first. (This is short-circuit logic.)

在这�情况下，象 /auth/user/add/ 的请求将会被 user_add_stage 视图处�。尽管URL也匹�第二�模�，它会先匹�上�的模�。（这是短路逻辑。）

Capturing Text in URLs

从URL中�获文本

Each captured argument is sent to the view as a plain Python string, regardless of what sort of match the regular expression makes. For example, in this URLconf line:

�个被�获的�数将被作为纯Python字符串���，而�管正则表达�中的格�。举个例�，在这行URLConf中：

(r'^articles/(?P<year>\d{4})/$', views.year_archive),

the year argument to views.year_archive() will be a string, not an integer, even though \d{4} will only match integer strings.

尽管 \d{4} 将�匹�整数的字符串，但是�数 year 是作为字符串传至 views.year_archive() 的，而�是整型。

This is important to keep in mind when youre writing view code. Many built-in Python functions are fussy (and rightfully so) about accepting only objects of a certain type. A common error is to attempt to create a datetime.date object with string values instead of integer values:

当你在写视图代�时记�这点很��，许多Python内建的方法对于接�的对象的类型很讲究。一个典型的的错误就是用字符串值而�是整数值�创建 datetime.date 对象：

>>> import datetime
>>> datetime.date('1993', '7', '9')
Traceback (most recent call last):
    ...
TypeError: an integer is required
>>> datetime.date(1993, 7, 9)
datetime.date(1993, 7, 9)

Translated to a URLconf and view, the error looks like this:

回到URLconf和视图处，错误看起�很�能是这样：

# urls.py

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^articles/(\d{4})/(\d{2})/(\d{2})/$', views.day_archive),
)

# views.py

import datetime

def day_archive(request, year, month, day)
    # The following statement raises a TypeError!
    date = datetime.date(year, month, day)

Instead, day_archive() can be written correctly like this:

因此， day_archive() 应该这样写�是正确的：

def day_archive(request, year, month, day)
    date = datetime.date(int(year), int(month), int(day))

Note that int() itself raises a ValueError when you pass it a string that is not composed solely of digits, but were avoiding that error in this case because the regular expression in our URLconf has ensured that only strings containing digits are passed to the view function.

注�，当你传递了一个并�完全包�数字的字符串时， int() 会抛出 ValueError 的异常，�过我们已���了这个错误，因为在URLconf的正则表达�中已�确��有包�数字的字符串�会传到这个视图函数中。

Determining What the URLconf Searches Against

决定URLconf�索的东西

When a request comes in, Django tries to match the URLconf patterns against the requested URL, as a normal Python string (not as a Unicode string). This does not include GET or POST parameters, or the domain name. It also does not include the leading slash, because every URL has a leading slash.

当一个请求进�时，Django试�将请求的URL作为一个普通Python字符串进行URLconf模�匹�（而�是作为一个Unicode字符串）。这并�包括 GET 或 POST �数或域�。它也�包括第一个斜�，因为�个URL必定有一个斜�。

For example, in a request to http://www.example.com/myapp/ , Django will try to match myapp/ . In a request to http://www.example.com/myapp/?page=3 , Django will try to match myapp/ .

例如，在� http://www.example.com/myapp/ 的请求中，Django将试�去匹� myapp/ 。在� http://www.example.com/myapp/?page=3 的请求中，Django�样会去匹� myapp/ 。

The request method (e.g., POST , GET , HEAD ) is not taken into account when traversing the URLconf. In other words, all request methods will be routed to the same function for the same URL. Its the responsibility of a view function to perform branching based on request method.

在解�URLconf时，请求方法（例如， POST ， GET ， HEAD ）并 �会 被考虑。�而言之，对于相�的URL的所有请求方法将被导�到相�的函数中。因此根�请求方法�处�分支是视图函数的责任。

How Captured Parameters Work with include()

�获的�数如何和include()��工作

An included URLconf receives any captured parameters from parent URLconfs, for example:

一个被包�的URLconf接收任何�自parent URLconfs的被�获的�数，比如:

# root urls.py

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^(?P<username>\w+)/blog/', include('foo.urls.blog')),
)

# foo/urls/blog.py

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^$', 'foo.views.blog_index'),
    (r'^archive/$', 'foo.views.blog_archive'),
)

In this example, the captured username variable is passed to the included URLconf and, hence, to every view function within that URLconf.

在这个例�中，被�获的 username ��将传递给被包�的 URLconf，进而传递给那个URLconf中的 �一个 视图函数。

Note that the captured parameters will always be passed to every line in the included URLconf, regardless of whether the lines view actually accepts those parameters as valid. For this reason, this technique is useful only if youre certain that every view in the included URLconf accepts the parameters youre passing.

注�，这个被�获的�数 总是 传递到被包�的URLconf中的 �一 行，�管那些行对应的视图是�需�这些�数。因此，这个技术�有在你确实需�那个被传递的�数的时候�显得有用。

How Extra URLconf Options Work with include()

�外的URLconf如何和include()��工作

Similarly, you can pass extra URLconf options to include() , just as you can pass extra URLconf options to a normal view as a dictionary. When you do this, each line in the included URLconf will be passed the extra options.

相似的，你�以传递�外的URLconf选项到 include() , 就�你�以通过字典传递�外的URLconf选项到普通的视图。当你这样�的时候，被包�URLconf的 �一 行都会收到那些�外的�数。

For example, the following two URLconf sets are functionally identical.

比如，下�的两个URLconf在功能上是相等的。

Set one:

第一个：

# urls.py

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^blog/', include('inner'), {'blogid': 3}),
)

# inner.py

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^archive/$', 'mysite.views.archive'),
    (r'^about/$', 'mysite.views.about'),
    (r'^rss/$', 'mysite.views.rss'),
)

Set two:

第二个

# urls.py

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^blog/', include('inner')),
)

# inner.py

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^archive/$', 'mysite.views.archive', {'blogid': 3}),
    (r'^about/$', 'mysite.views.about', {'blogid': 3}),
    (r'^rss/$', 'mysite.views.rss', {'blogid': 3}),
)

As is the case with captured parameters (explained in the previous section), extra options will always be passed to every line in the included URLconf, regardless of whether the lines view actually accepts those options as valid. For this reason, this technique is useful only if youre certain that every view in the included URLconf accepts the extra options youre passing.

这个例�和��关于被�获的�数一样（在上一节就解释过这一点），�外的选项将 总是 被传递到被包�的URLconf中的 �一 行，�管那一行对应的视图是�确实作为有效�数接收这些选项，因此，这个技术�有在你确实需�那个被传递的�外�数的时候�显得有用。