Changes between Initial Version and Version 1 of DjangoDocumentKoreanTranslation/overview.txt


Ignore:
Timestamp:
11/14/07 08:54:45 (7 years ago)
Author:
spike
Comment:

--

Legend:

Unmodified
Added
Removed
Modified
  • DjangoDocumentKoreanTranslation/overview.txt

    v1 v1  
     1{{{
     2==================
     3>>!
     4Django at a glance
     5<<!
     6>>!!
     7한눈에 보는 장고
     8<<!!
     9==================
     10
     11>>!
     12Because Django was developed in a fast-paced newsroom environment, it was
     13designed to make common Web-development tasks fast and easy. Here's an informal
     14overview of how to write a database-driven Web app with Django.
     15
     16The goal of this document is to give you enough technical specifics to
     17understand how Django works, but this isn't intended to be a tutorial or
     18reference. Please see our more-detailed Django documentation_ when you're ready
     19to start a project.
     20<<!
     21>>!!
     22처음 장고는 뉴스편집 시스템으로 개발되었습니다. 그 덕분에 웹서비스를
     23쉽고 빠르게 개발할 수 있도록 설계되었습니다. 여기서는 장고로
     24데이터베이스를 이용한 간단한 웹 어플리케이션을 작성하는 예를
     25설명합니다.
     26
     27이 문서에서 장고가 실제로 어떻게 동작하는지 충분한 기술적인 내용을
     28설명합니다. 다만 이 문서는 자세한 설명서나 참조문서가 아니기 때문에
     29좀더 자세한 내용은 장고 `도움말 문서`_를 참고하세요.
     30<<!!
     31
     32>>!
     33.. _documentation: ../
     34<<!
     35>>!!
     36.. _도움말 문서: ../
     37<<!!
     38
     39>>!
     40Design your model
     41<<!
     42>>!!
     43모델(model) 설계
     44<<!!
     45=================
     46
     47>>!
     48Although you can use Django without a database, it comes with an
     49object-relational mapper in which you describe your database layout in Python
     50code.
     51
     52The data-model syntax offers many rich ways of representing your models -- so
     53far, it's been solving two years' worth of database-schema problems. Here's a
     54quick example::
     55<<!
     56>>!!
     57데이터베이스 없이 장고를 사용한다고 해도 장고는 파이썬으로
     58데이터베이스 윤곽을 설명하는 객체-관계 매퍼(object-relational
     59mapper)를 가지고 있습니다.
     60
     61데이터 모델(data-model) 구문으로 모델을 자세히 표현할 수
     62있습니다. -- 우리는 2년에 걸쳐서 데이터베이스 스키마를 표현하는 방법을
     63고안해냈습니다. 예를 들어서::
     64<<!!
     65
     66    class Reporter(models.Model):
     67        full_name = models.CharField(max_length=70)
     68
     69        def __unicode__(self):
     70            return self.full_name
     71
     72    class Article(models.Model):
     73        pub_date = models.DateTimeField()
     74        headline = models.CharField(max_length=200)
     75        article = models.TextField()
     76        reporter = models.ForeignKey(Reporter)
     77
     78        def __unicode__(self):
     79            return self.headline
     80
     81>>!
     82Install it
     83<<!
     84>>!!
     85설치하기
     86<<!!
     87==========
     88
     89>>!
     90Next, run the Django command-line utility to create the database tables
     91automatically::
     92<<!
     93>>!!
     94그럼 이제 장고의 명령행 스크립트로 데이터베이스를 자동으로
     95만듭니다.::
     96<<!!
     97
     98    manage.py syncdb
     99
     100>>!
     101The ``syncdb`` command looks at all your available models and creates tables
     102in your database for whichever tables don't already exist.
     103<<!
     104>>!!
     105``syncdb`` 명령은 사용할 수 있는 모든 모델을 찾아서 데이터베이스에
     106테이블을 만듭니다.
     107<<!!
     108
     109>>!
     110Enjoy the free API
     111<<!
     112>>!!
     113API를 사용해보세요
     114<<!!
     115==================
     116
     117>>!
     118With that, you've got a free, and rich, Python API to access your data. The API
     119is created on the fly, no code generation necessary::
     120<<!
     121>>!!
     122파이썬 API를 통해서 데이터에 접근하는 편리하고 풍부한 방법을
     123제공합니다. 코드를 미리 만들 필요 없이 바로 API를 사용할 수
     124있습니다.::
     125<<!!
     126
     127>>!
     128    >>> from mysite.models import Reporter, Article
     129
     130    # No reporters are in the system yet.
     131    >>> Reporter.objects.all()
     132    []
     133
     134    # Create a new Reporter.
     135    >>> r = Reporter(full_name='John Smith')
     136
     137    # Save the object into the database. You have to call save() explicitly.
     138    >>> r.save()
     139
     140    # Now it has an ID.
     141    >>> r.id
     142    1
     143
     144    # Now the new reporter is in the database.
     145    >>> Reporter.objects.all()
     146    [John Smith]
     147
     148    # Fields are represented as attributes on the Python object.
     149    >>> r.full_name
     150    'John Smith'
     151
     152    # Django provides a rich database lookup API.
     153    >>> Reporter.objects.get(id=1)
     154    John Smith
     155    >>> Reporter.objects.get(full_name__startswith='John')
     156    John Smith
     157    >>> Reporter.objects.get(full_name__contains='mith')
     158    John Smith
     159    >>> Reporter.objects.get(id=2)
     160    Traceback (most recent call last):
     161        ...
     162    DoesNotExist: Reporter does not exist for {'id__exact': 2}
     163
     164    # Create an article.
     165    >>> from datetime import datetime
     166    >>> a = Article(pub_date=datetime.now(), headline='Django is cool',
     167    ...     article='Yeah.', reporter=r)
     168    >>> a.save()
     169
     170    # Now the article is in the database.
     171    >>> Article.objects.all()
     172    [Django is cool]
     173
     174    # Article objects get API access to related Reporter objects.
     175    >>> r = a.reporter
     176    >>> r.full_name
     177    'John Smith'
     178
     179    # And vice versa: Reporter objects get API access to Article objects.
     180    >>> r.article_set.all()
     181    [Django is cool]
     182
     183    # The API follows relationships as far as you need, performing efficient
     184    # JOINs for you behind the scenes.
     185    # This finds all articles by a reporter whose name starts with "John".
     186    >>> Article.objects.filter(reporter__full_name__startswith="John")
     187    [Django is cool]
     188
     189    # Change an object by altering its attributes and calling save().
     190    >>> r.full_name = 'Billy Goat'
     191    >>> r.save()
     192
     193    # Delete an object with delete().
     194    >>> r.delete()
     195<<!
     196>>!!
     197    >>> from mysite.models import Reporter, Article
     198
     199    # 아직 기자가 없습니다.
     200    >>> Reporter.objects.all()
     201    []
     202
     203    # 기자를 새로 추가합니다.
     204    >>> r = Reporter(full_name='John Smith')
     205
     206    # save() 메소드로 데이터베이스에 객체를 저장합니다.
     207    >>> r.save()
     208
     209    # ID가 있군요
     210    >>> r.id
     211    1
     212
     213    # 이제 데이터베이스에 새 기자가 있군요.
     214    >>> Reporter.objects.all()
     215    [John Smith]
     216
     217    # 데이터베이스 필드는 파이썬의 속성으로 표현됩니다.
     218    >>> r.full_name
     219    'John Smith'
     220
     221    # 아래 방법으로 데이터베이스 쿼리를 표현할 수 있습니다.
     222    >>> Reporter.objects.get(id=1)
     223    John Smith
     224    >>> Reporter.objects.get(full_name__startswith='John')
     225    John Smith
     226    >>> Reporter.objects.get(full_name__contains='mith')
     227    John Smith
     228    >>> Reporter.objects.get(id=2)
     229    Traceback (most recent call last):
     230        ...
     231    DoesNotExist: Reporter does not exist for {'id__exact': 2}
     232
     233    # 기사를 만듭니다.
     234    >>> from datetime import datetime
     235    >>> a = Article(pub_date=datetime.now(), headline='Django is cool',
     236    ...     article='Yeah.', reporter=r)
     237    >>> a.save()
     238
     239    # Now the article is in the database.
     240    # 데이터베이스에서 기사를 확인합니다.
     241    >>> Article.objects.all()
     242    [Django is cool]
     243
     244    # 기사(Article) 객체는 기자(Reporter) 객체에 관계(related) 모델로
     245    # 접근할 수 있습니다.
     246    >>> r = a.reporter
     247    >>> r.full_name
     248    'John Smith'
     249
     250    # 반대로 기자(Reporter) 객체에서도 기사(Article) 객체에 접근할 수
     251    # 있습니다.
     252    >>> r.article_set.all()
     253    [Django is cool]
     254
     255    # API는 필요에 따라서 관계(relationship)를 적용시킬 수 있습니다.
     256    # 효율적으로 JOIN을 사용하기 때문입니다.
     257    # 아래 코드는 "John"으로 시작하는 기자의 모든 기사를 가져옵니다.
     258    >>> Article.objects.filter(reporter__full_name__startswith="John")
     259    [Django is cool]
     260
     261    # 속성을 변경시키고 save()해서 객체를 변경시킬 수 있습니다.
     262    >>> r.full_name = 'Billy Goat'
     263    >>> r.save()
     264
     265    # delete()로 객체를 삭제합니다.
     266    >>> r.delete()
     267<<!!
     268
     269>>!
     270A dynamic admin interface: it's not just scaffolding -- it's the whole house
     271<<!
     272>>!!
     273동적인 관리 인터페이스: 단순한 스캐폴딩(scaffolding)이 아니라 그 이상입니다.
     274<<!!
     275============================================================================
     276
     277>>!
     278Once your models are defined, Django can automatically create a professional,
     279production ready administrative interface -- a Web site that lets authenticated
     280users add, change and delete objects. It's as easy as adding a line of code to
     281your model classes::
     282<<!
     283>>!!
     284모델(model)을 정의하면 장고는 실제 운영에 적합한 전문적인 관리
     285인터페이스를 만들어냅니다. -- 등록된 사용자를 더하고, 바꾸고, 지우는
     286웹 사이트입니다. 모델에 한줄을 추가하는 것으로 쉽게 적용할 수
     287있습니다.::
     288<<!!
     289
     290    class Article(models.Model):
     291        pub_date = models.DateTimeField()
     292        headline = models.CharField(max_length=200)
     293        article = models.TextField()
     294        reporter = models.ForeignKey(Reporter)
     295        class Admin: pass
     296
     297>>!
     298The philosophy here is that your site is edited by a staff, or a client, or
     299maybe just you -- and you don't want to have to deal with creating backend
     300interfaces just to manage content.
     301
     302One typical workflow in creating Django apps is to create models and get the
     303admin sites up and running as fast as possible, so your staff (or clients) can
     304start populating data. Then, develop the way data is presented to the public.
     305<<!
     306>>!!
     307아이디어는 이렇습니다. 운영자나 고객, 혹은 여러분이 사이트를
     308관리하면서 그 아래의 인터페이스까지 다룰 필요는 없어야 한다는
     309것입니다.
     310
     311장고에서 웹 어플리케이션을 만드는 전형적인 과정은, 모델을 만들고 관리
     312사이트에서 관리하면서 최대한 빠르게 작동시키도록 합니다. 그래서 운영자
     313혹은 고객이 데이터를 만들어냅니다. 그리고 나서 데이터를 표현하도록
     314개발합니다.
     315<<!!
     316
     317>>!
     318Design your URLs
     319<<!
     320>>!!
     321URL 설계하기
     322<<!!
     323================
     324
     325>>!
     326A clean, elegant URL scheme is an important detail in a high-quality Web
     327application. Django encourages beautiful URL design and doesn't put any cruft
     328in URLs, like ``.php`` or ``.asp``.
     329
     330To design URLs for an app, you create a Python module called a URLconf. A table
     331of contents for your app, it contains a simple mapping between URL patterns and
     332Python callback functions. URLconfs also serve to decouple URLs from Python
     333code.
     334
     335Here's what a URLconf might look like for the ``Reporter/Article``
     336example above::
     337<<!
     338>>!!
     339깔끔하고 우아한 URL 구조는 웹 어플리케이션의 품질을 향상시키는 중요한
     340부분입니다. 장고는 `.php`, `.asp` 같은 군더더기 없이 URL을 이쁘게 만들
     341수 있도록 도와줍니다.
     342
     343``URLconf``을 작성합니다. 어플리케이션의 목차라고 생각하시면 됩니다.
     344여기에는 URL 패턴(URL patterns)과 파이썬 콜백(Python callback)을
     345간단하게 연결시킵니다. ``URLconf``는 파이썬 코드에서 URL을 분리시키는
     346역할도 합니다.
     347
     348아래에서는 ``Reporter/Article``라는 URL이 ``URLconf``에서 어떻게
     349표현되는지 설명합니다.::
     350<<!!
     351
     352    from django.conf.urls.defaults import *
     353
     354    urlpatterns = patterns('',
     355        (r'^articles/(\d{4})/$', 'mysite.views.year_archive'),
     356        (r'^articles/(\d{4})/(\d{2})/$', 'mysite.views.month_archive'),
     357        (r'^articles/(\d{4})/(\d{2})/(\d+)/$', 'mysite.views.article_detail'),
     358    )
     359
     360>>!
     361The code above maps URLs, as simple regular expressions, to the location of
     362Python callback functions ("views"). The regular expressions use parenthesis to
     363"capture" values from the URLs. When a user requests a page, Django runs
     364through each pattern, in order, and stops at the first one that matches the
     365requested URL. (If none of them matches, Django calls a special-case 404 view.)
     366This is blazingly fast, because the regular expressions are compiled at load
     367time.
     368
     369Once one of the regexes matches, Django imports and calls the given view, which
     370is a simple Python function. Each view gets passed a request object --
     371which contains request metadata -- and the values captured in the regex.
     372
     373For example, if a user requested the URL "/articles/2005/05/39323/", Django
     374would call the function ``mysite.views.article_detail(request,
     375'2005', '05', '39323')``.
     376<<!
     377>>!!
     378간단하게 정규표현식(regular expressions)으로 표현된 URL과 파이썬
     379콜백(Python callback)의 위치를 연결시켰습니다. 정규표현식에서
     380괄호(``()``)를 이용해서 URL에서 값을 가져옵니다. 페이지가 호출되면
     381장고는 각 패턴(pattern)들을 순서대로 비교해서 먼저 일치하는 것을
     382선택합니다. (일치하는 패턴이 없으면, 장고는 404 뷰(view)를
     383호출합니다.) 장고가 처음 실행될 때 정규표현식을 읽어들이기 때문에 이
     384과정은 아주 빠르게 일어납니다.
     385
     386일치되는 패턴(pattern)이 있으면, 장고는 패턴에서 정의한 간단한 파이썬
     387함수(function)인 뷰(view)를 호출합니다. 각 뷰(view)는 request
     388metadata를 가지고 있는 request 객체를 함께 넘겨받습니다. -- 그리고
     389앞에서 설명한 정규표현식으로 걸러낸 값들도 함께 넘겨받습니다.
     390
     391아래 예에서 설명한 URLconf에서는 "``/articles/2005/05/39323/``"이라는
     392URL을 호출할 경우 장고는
     393`mysite.views.article_detail(request, '2005', '05', '39323')``라고
     394뷰(view)를 호출합니다.
     395<<!!
     396
     397>>!
     398Write your views
     399<<!
     400>>!!
     401뷰(view) 작성하기
     402<<!!
     403================
     404
     405>>!
     406Each view is responsible for doing one of two things: Returning an
     407``HttpResponse`` object containing the content for the requested page, or
     408raising an exception such as ``Http404``. The rest is up to you.
     409
     410Generally, a view retrieves data according to the parameters, loads a template
     411and renders the template with the retrieved data. Here's an example view for
     412``year_archive`` from above::
     413<<!
     414>>!!
     415뷰(view)는 두가지 일을 합니다.: 페이지 내용을 담고 있는
     416``HttpResponse`` 객체를 반환합니다. 혹은 ``Http404``라는 예외를
     417발생시킵니다.
     418
     419보통은 뷰(view) 파라미터(parameters)에 따라서 데이터를 가져와서,
     420가져온 데이터와 템플릿(template)으로 페이지를 만듭니다. 아래 예에서는
     421위에서 설명한 ``year_archive`` 뷰(view)를 설명합니다.::
     422<<!!
     423
     424    def year_archive(request, year):
     425        a_list = Article.objects.filter(pub_date__year=year)
     426        return render_to_response('news/year_archive.html', {'year': year, 'article_list': a_list})
     427
     428>>!
     429This example uses Django's template system, which has several powerful
     430features but strives to stay simple enough for non-programmers to use.
     431<<!
     432>>!!
     433장고 템플릿(template)을 사용했습니다. 템플릿은 매우 강력한 방법이면서
     434프로그래머가 아니더라도 충분히 사용할 수 있습니다.
     435<<!!
     436
     437>>!
     438Design your templates
     439<<!
     440>>!!
     441템플릿 디자인하기
     442<<!!
     443=====================
     444
     445>>!
     446The code above loads the ``news/year_archive.html`` template.
     447
     448Django has a template search path, which allows you to minimize redundancy among
     449templates. In your Django settings, you specify a list of directories to check
     450for templates. If a template doesn't exist in the first directory, it checks the
     451second, and so on.
     452
     453Let's say the ``news/article_detail.html`` template was found. Here's what that
     454might look like::
     455<<!
     456>>!!
     457위 예에서 ``news/year_archive.html`` 템플릿을 사용했습니다.
     458
     459장고는 쉽게 템플릿을 가져오도록 템플릿 경로(template search path)를
     460사용합니다. 장고 설정(settings)에서 템플릿이 있는 디렉토리를
     461지정해줍니다. 첫번째 디렉토리에서 찾는 템필릿이 없으면 그 다음
     462디렉토리로 넘어갑니다.
     463
     464다음과 같은 ``news/article_detail.html`` 템플릿이 있습니다.::
     465<<!!
     466
     467    {% extends "base.html" %}
     468
     469    {% block title %}Articles for {{ year }}{% endblock %}
     470
     471    {% block content %}
     472    <h1>Articles for {{ year }}</h1>
     473
     474    {% for article in article_list %}
     475    <p>{{ article.headline }}</p>
     476    <p>By {{ article.reporter.full_name }}</p>
     477    <p>Published {{ article.pub_date|date:"F j, Y" }}</p>
     478    {% endfor %}
     479    {% endblock %}
     480
     481>>!
     482Variables are surrounded by double-curly braces. ``{{ article.headline }}``
     483means "Output the value of the article's headline attribute." But dots aren't
     484used only for attribute lookup: They also can do dictionary-key lookup, index
     485lookup and function calls.
     486
     487Note ``{{ article.pub_date|date:"F j, Y" }}`` uses a Unix-style "pipe" (the "|"
     488character). This is called a template filter, and it's a way to filter the value
     489of a variable. In this case, the date filter formats a Python datetime object in
     490the given format (as found in PHP's date function; yes, there is one good idea
     491in PHP).
     492
     493You can chain together as many filters as you'd like. You can write custom
     494filters. You can write custom template tags, which run custom Python code behind
     495the scenes.
     496
     497Finally, Django uses the concept of "template inheritance": That's what the
     498``{% extends "base.html" %}`` does. It means "First load the template called
     499'base', which has defined a bunch of blocks, and fill the blocks with the
     500following blocks." In short, that lets you dramatically cut down on redundancy
     501in templates: each template has to define only what's unique to that template.
     502
     503Here's what the "base.html" template might look like::
     504<<!
     505>>!!
     506변수는 브레이스(``{{, }}``) 두개를 묶어서 표현합니다.
     507``{{ article.headline }}``는 article 객체의 headline 속성(attribute)을
     508뜻합니다. 변수를 표현할 때 속성(attribute)뿐 아니라 사전의
     509키(dictionary-key), 리스트의 인덱스(index) 그리고 메소드까지 호출할 수
     510있습니다.
     511
     512``{{ article.pub_date|date:"F j, Y" }}``에서처럼 유닉스에서 많이 사용되는
     513"pipe"("|")와 비슷하게 사용하는 템플릿 필터(template filter)를 사용할
     514수 있습니다. 이 필터는 원하는 형식으로 article.pub_date의 파이썬
     515datetime 객체를 바꿔줍니다. (PHP의 date 함수에서처럼; PHP에도 좋은
     516아이디어가 있군요.)
     517
     518원하면 얼마든지 많은 필터를 결합시킬 수 있습니다. 필터를 직접 작성할
     519수도 있구요. 템플릿 필터, 템필릿 태그(template tags)도 작성할 수
     520있습니다.
     521
     522마지막으로 장고는 "템플릿 상속(template inheritance)"이라는 개념이
     523있습니다.: 위 템플릿 예에서 ``{% extends "base.html" %}``이 바로
     524이것입니다. 블록 구조(blocks)를 정의한 "base.html"의 블록 구조를
     525사용한다는 뜻입니다. 이런 방법으로 템플릿의 중복을 극적으로
     526줄여줍니다.: 각각의 템플릿은 그 템플릿에 맞도록 정의되어야 합니다.
     527
     528"base.html" 템플릿은 이렇게 생겼습니다.::
     529<<!!
     530
     531    <html>
     532    <head>
     533        <title>{% block title %}{% endblock %}</title>
     534    </head>
     535    <body>
     536        <img src="sitelogo.gif" alt="Logo" />
     537        {% block content %}{% endblock %}
     538    </body>
     539    </html>
     540
     541>>!
     542Simplistically, it defines the look-and-feel of the site (with the site's logo),
     543and provides "holes" for child templates to fill. This makes a site redesign as
     544easy as changing a single file -- the base template.
     545
     546It also lets you create multiple versions of a site, with different base
     547templates, while reusing child templates. Django's creators have used this
     548technique to create strikingly different cell-phone editions of sites -- simply
     549by creating a new base template.
     550
     551Note that you don't have to use Django's template system if you prefer another
     552system. While Django's template system is particularly well-integrated with
     553Django's model layer, nothing forces you to use it. For that matter, you don't
     554have to use Django's database API, either. You can use another database
     555abstraction layer, you can read XML files, you can read files off disk, or
     556anything you want. Each piece of Django -- models, views, templates -- is
     557decoupled from the next.
     558<<!
     559>>!!
     560아주 단순하게 사이트의 모양(사이트 로고까지)을 정의했습니다. 그리고
     561"base.html"을 상속받는 다른 템플릿이 사용하도록 구멍(block)도
     562정의했습니다. 이 기본 템플릿을 사용해서 각 페이지의 템플릿을 변경하지
     563않고 "base.html"을 사용해서 사이트 모양을 바꿀 수 있습니다.
     564
     565기본 템플릿만 다르게 해서 동일한 하위 템플릿을 이용해서 여러 모양의
     566사이트를 만들 수도 있습니다. 장고를 만든 저희들은 이 방법을 사용해서
     567새로운 기본 템플릿을 만들어서 하나의 사이트를 완전히 다른 핸드폰용
     568사이트로 사용하기도 했습니다.
     569
     570장고의 모델(model)을 적용시킬 수만 있다면 다른 템플릿 시스템을
     571사용할 수도 있습니다. 좀더 들어가서, 장고의 데이터베이스 API도
     572마찬가지입니다. 다른 데이터베이스 API를 사용할 수도 있습니다.
     573
     574    (역자주: 다른 데이터베이스 API를 사용할 수도 있지만, 몇가지 문제가
     575    있습니다.
     576        * 먼저 장고가 기본으로 제공하는 관리 사이트(admin site)를 사용할
     577          수 없습니다.
     578        * 그리고 장고에 포함된 폼 관련 라이브러리(newforms, forms) 등도
     579          사용할 수 없습니다.
     580    이런 장고 모델과 엮여있는 기능이 필요없다면 SQLObject나 SQLAlchemy 등
     581    파이썬의 ORM model을 사용하는 것도 좋은 시도입니다.)
     582
     583데이터베이스 API, XML 파일 읽기, 디스크에서 파일 읽어들이기, 혹은
     584장고의 어떤 부분도 다른 것으로 대체할 수 있습니다. -- 모델(model),
     585뷰(view), 템플릿(template).
     586<<!!
     587>>!
     588This is just the surface
     589<<!
     590>>!!
     591이상 맛보기였습다.
     592<<!!
     593========================
     594
     595>>!
     596This has been only a quick overview of Django's functionality. Some more useful
     597features:
     598<<!
     599>>!!
     600빨리 장고를 기능 중심으로 살펴보았습니다. 다른 기능들도 살펴봅니다.:
     601<<!!
     602
     603>>!
     604    * A caching framework that integrates with memcached or other backends.
     605    * A `syndication framework`_ that makes creating RSS and Atom feeds as easy as
     606      writing a small Python class.
     607    * More sexy automatically-generated admin features -- this overview barely
     608      scratched the surface.
     609<<!
     610>>!!
     611    * memcached나 다른 백엔드를 사용하는 캐슁 프레임워크(caching
     612      framework).
     613    * RSS나 Atom 피드를 쉽게 만들어주는 `syndication framework`.
     614    * 매력적인 기능을 가진 관리 사이트(admin site).
     615<<!!
     616
     617>>!
     618.. _syndication framework: ../syndication_feeds/
     619<<!
     620>>!!
     621<<!!
     622
     623>>!
     624The next obvious steps are for you to `download Django`_, read `the tutorial`_
     625and join `the community`_. Thanks for your interest!
     626<<!
     627>>!!
     628이제 `장고를 다운로드`_해서
     629`첫번째: 처음 실행하기, 모델(model) 만들기, 데이터베이스 API`_를
     630읽어보세요. 그리고 `장고 사용자 모임`_에도 들러보세요. 관심을
     631가져주셔서 감사합니다.
     632<<!!
     633
     634>>!
     635.. _download Django: http://www.djangoproject.com/download/
     636.. _the tutorial: ../tutorial01/
     637.. _the community: http://www.djangoproject.com/community/
     638<<!
     639>>!!
     640.. _장고를 다운로드: http://www.djangoproject.com/download/
     641.. _첫번째: 처음 실행하기, 모델(model) 만들기, 데이터베이스 API: ../tutorial01/
     642.. _장고 사용자 모임: http://www.djangoproject.com/community/
     643<<!!
     644}}}
Back to Top