Changes between Version 1 and Version 2 of DocPtOverview


Ignore:
Timestamp:
11/10/2006 04:52:46 AM (9 years ago)
Author:
foo@…
Comment:

DocPtOverview

Legend:

Unmodified
Added
Removed
Modified
  • DocPtOverview

    v1 v2  
    1 foo
     1{{{
     2#!rst
     3
     4THIS TRANSLATION IS IN PROGRESS:
     5^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     6+-------------------------------------------------------------------------------------------------+
     7|    This is an **in progress** translation document, that means there is somebody working on it. |
     8|    For more information on translating documents please look at `TranslateDocumentation Wiki`_. |
     9|    Please **do not** edit this page.                                                            |
     10|                                                                                                 |
     11| .. _TranslateDocumentation Wiki :      |
     12+-------------------------------------------------------------------------------------------------+   
     13
     14..
     15  ===============
     16  Django Overview
     17  ===============
     18
     19.. sidebar:: Uma rápida olhada no Django
     20  :subtitle: tradução para o português.
     21
     22  Documento original: `Django Overview`_
     23 
     24  Tradução: Kao Cardoso Félix `<kcfelix at gmail.com>`
     25 
     26  Referente a revisão: 3896
     27
     28.. _Django Overview:
     29
     30.. contents:: **Conteúdos do capítulo**
     31
     32===========================
     33Uma rápida olhada no Django
     34===========================
     35
     36Este documento cobre a versão 0.95 de Django e a versão do desenvolvimento. Docs anteriores: `0.90`_, `0.91`_
     37
     38.. _0.90: 
     39.. _0.91:
     40
     41Como o Django foi desenvolvido dentro do ambiente ágil de uma "newsroom", ele foi
     42projetado para fazer as tarefas comuns do desenvolvimento Web serem rápidas e fáceis.
     43Aqui está um "overview" informal de como escrever um Aplicativo Web com Banco de Dados
     44usando o Django
     45
     46O objetivo desse documento é lhe dar informações técnicas específicas suficientes
     47para que você entenda como o Django funciona, mas não ser um tutorial ou uma referência.
     48Por favor, veja a documentação_ detalhada do Django quando você estiver pronto para
     49iniciar um projeto.
     50
     51.. _documentação:
     52
     53Projete seu modelo
     54==================
     55
     56Apesar de você poder usar o Django sem um banco de dados, ele vem com um mapeador Objeto-Relacional
     57em que você descreve a estrutura dos seus dados em Python.
     58
     59A sintaxe de modelo de dados oferece diversas maneiras ricas de representar os seus modelos -- até
     60agora, já esteve resolvendo problemas de "database-schema" equivalentes a dois anos. Aqui está um
     61rápido exemplo::
     62
     63    class Reporter(models.Model):
     64        full_name = models.CharField(maxlength=70)
     65
     66        def __str__(self):
     67            return self.full_name
     68
     69    class Article(models.Model):
     70        pub_date = models.DateTimeField()
     71        headline = models.CharField(maxlength=200)
     72        article = models.TextField()
     73        reporter = models.ForeignKey(Reporter)
     74
     75        def __str__(self):
     76            return self.headline
     77
     78Instale-o
     79=========
     80
     81O próximo passo é executar o utilitário de linha de comando do Django
     82para criar as tabelas do banco de dados automaticamente::
     83
     84    manage.py syncdb
     85
     86O comando ``syncdb`` vai "olhar" para todos os seus modelos disponíveis
     87e criar tabelas no seu banco de dados para quaisquer modelos que ainda
     88não tenham uma tabela correspondente.
     89
     90Aproveite a API
     91===============
     92
     93Com isso você ganha de graça (?) uma rica API em Python para acessar seus dados.
     94A API é criada na hora: Sem geração de código::
     95
     96    >>> from mysite.models import Reporter, Article
     97
     98    # Ainda não existem repórteres no sistema.
     99    >>> Reporter.objects.all()
     100    []
     101
     102    # Cria um novo repórter.
     103    >>> r = Reporter(full_name='John Smith')
     104
     105    # Salva o objeto no banco de dados. Você deve chamar save() explicitamente.
     106    >>> r.save()
     107
     108    # Agora ele tem uma ID.
     109    >>> r.id
     110    1
     111
     112    # Agora o novo repórter está no banco de dados.
     113    >>> Reporter.objects.all()
     114    [John Smith]
     115
     116    # Campos são representados como atributos do objeto Python.
     117    >>> r.full_name
     118    'John Smith'
     119
     120    # O Django provê uma rica API de buscas no banco de dados.
     121    >>> Reporter.objects.get(id=1)
     122    John Smith
     123    >>> Reporter.objects.get(full_name__startswith='John')
     124    John Smith
     125    >>> Reporter.objects.get(full_name__contains='mith')
     126    John Smith
     127    >>> Reporter.objects.get(id=2)
     128    Traceback (most recent call last):
     129        ...
     130    DoesNotExist: Reporter does not exist for {'id__exact': 2}
     131
     132    # Cria um artigo.
     133    >>> from datetime import datetime
     134    >>> a = Article(pub_date=datetime.now(), headline='Django is cool',
     135    ...     article='Yeah.', reporter=r)
     136    >>> a.save()
     137
     138    # Agora o artigo está no banco de dados.
     139    >>> Article.objects.all()
     140    [Django is cool]
     141
     142    # Objetos de Artigo ganham acesso aos objetos Reporter relacionados através da API.
     143    >>> r = a.reporter
     144    >>> r.full_name
     145    'John Smith'
     146
     147    # E vice versa: objetos Reporter ganham aceso a objetos Artigo através da API.
     148    >>> r.article_set.all()
     149    [Django is cool]
     150   
     151    # A API segue relacionamentos tanto quanto você precisar, fazendo
     152    # JOINs eficientes para você por trás das cortinas.
     153    # Esse trecho encontra todos os artigos escritos por um repórter cujo nome começa por "John".
     154    >>> Article.objects.filter(reporter__full_name__startswith="John")
     155    [Django is cool]
     156
     157    # Mude um objeto alterando seus atributos e chamando save().
     158    >>> r.full_name = 'Billy Goat'
     159    >>> r.save()
     160
     161    # Apague um objeto com delete().
     162    >>> r.delete()
     163
     164Uma interface de administração dinâmica: Não é apenas a estrutura -- é a casa inteira
     165=====================================================================================
     166
     167Uma vez que seus modelos estejam definidos, o Django pode criar automaticamente uma interface
     168administrativa profissional e pronta para produção. Essa interface é um site que permite aos usuários
     169autenticados adicionar, alterar e excluir objetos. É tão fácil habilitar a interface para seu modelo
     170quanto é adicionar uma nova linha de código::
     171
     172    class Article(models.Model):
     173        pub_date = models.DateTimeField()
     174        headline = models.CharField(maxlength=200)
     175        article = models.TextField()
     176        reporter = models.ForeignKey(Reporter)
     177        class Admin: pass
     178
     179A filosofia aqui é que seu site é editado por um funcionário, um cliente ou
     180talvez você mesmo -- e você não quer lidar com a criação de uma interface
     181apenas para gerenciar conteúdo.
     182
     183Um fluxo de trabalho típico na criação de aplicativos Django é criar modelos
     184e botar os sites de administração para rodar o mais rápido possível para que
     185seus funcionários (ou clientes) possam começar a preencher os dados. Aí sim
     186desenvolver o modo como os dados serão apresentados ao público.
     187
     188Projete seus URLs
     189=================
     190
     191Um esquema de URL limpo e elegante é um detalhe importante em uma aplicação
     192Web de alta qualidade. Django encoraja a criação de URLs belos e não o
     193obriga a colocar nenhuma extensão feia como ``.php`` ou ``.asp``.
     194
     195Para criar URLs para o seu aplicativo você cria um módulo Python chamado URLconf.
     196Esse módulo contém um simples mapeamento entre padrões de URL e funções de "callback"
     197em Python. Módulos URLconf também servem para desacoplar URLs de código Python.
     198
     199Aqui está um possível URLconf para o exemplo de ``Repórte``/``Artigo`` de antes::
     200
     201    from django.conf.urls.defaults import *
     202
     203    urlpatterns = patterns('',
     204        (r'^/articles/(\d{4})/$', 'mysite.views.year_archive'),
     205        (r'^/articles/(\d{4})/(\d{2})/$', 'mysite.views.month_archive'),
     206        (r'^/articles/(\d{4})/(\d{2})/(\d+)/$', 'mysite.views.article_detail'),
     207    )
     208
     209O código acima mapeia URLs, com simples expressões regulares, para funções Python
     210de callback ("views"). As expressões regulares usam parênteses para "capturar"
     211valores das URLs. Quando um usuário acessa uma página, o Django irá passar por cada
     212um dos padrões, em ordem, e vai parar no primeiro que combina com o URL acessado.
     213(Se nenhum combinar o Django vai chamar uma "view" especial de erro 404.) Tudo isso
     214é incrivelmente rápido porque as expressões regulares são compiladas em tempo de
     215carregamento.
     216
     217Assim que uma das expressões combinar, o Django vai importar e chamar a "view" necessária,
     218que é uma função Python simples. Cada "view" recebe um objeto de "request" -- que contém
     219metadados de "request" -- e os valores capturados na expressão regular.
     220
     221Por exemplo, se um usuário acessa a URL "/articles/2005/05/39323/", o Django
     222iria chamar a função ``mysite.views.article_detail(request,
     223'2005', '05', '39323')``.
     224
     225Escreva suas "views"
     226====================
     227
     228Cada "view" é responsável por fazer uma de duas coisas: Retornar um objeto
     229``HttpResponse`` com o conteúdo da página requisitada ou levantar uma exceção,
     230por exemplo ``Http404``. O resto é com você.
     231
     232Geralmente, uma "view" obtém dados de acordo com os parâmetros, carrega
     233um template e renderiza o template com os dados obtidos. Aqui está um exemplo
     234de uma "view" para o ``year_archive`` mostrado acima::
     235
     236    def year_archive(request, year):
     237        a_list = Article.objects.filter(pub_date__year=year)
     238        return render_to_response('news/year_archive.html', {'year': year, 'article_list': a_list})
     239
     240Esse exemplo usa o sistema de "templates" do Django que tem muitas características
     241poderosas mas tenta sempre ficar simples o suficiente para não-programadores usá-lo.
     242
     243Crie seus "templates"
     244=====================
     245
     246O código acima carrega o template ``news/year_archive.html``.
     247
     248O Django tem um caminho de procura para templates permitindo que você minimize
     249a redundância entre os templates. Nas suas configurações do Django você especifica
     250uma lista de diretórios para procurar por templates. Se um template não existe no
     251primeiro diretório, ele procura no segundo e assim por diante.
     252
     253Vamos dizer que o template ``news/article_detail.html`` foi encontrado. Aqui está
     254como ele poderia ser::
     255
     256    {% extends "base.html" %}
     257
     258    {% block title %}Articles for {{ year }}{% endblock %}
     259
     260    {% block content %}
     261    <h1>Articles for {{ year }}</h1>
     262
     263    {% for article in article_list %}
     264    <p>{{ article.headline }}</p>
     265    <p>By {{ article.reporter.full_name }}</p>
     266    <p>Published {{ article.pub_date|date:"F j, Y" }}</p>
     267    {% endfor %}
     268    {% endblock %}
     269
     270Variáveis são envolvidas por duplas chaves. ``{{ article.headline }}`` significa
     271"Mostre o valor do atributo headline da variável article". Mas pontos não são usados
     272apenas para acessar atributos: eles também podem fazer acesso por chaves de dicionários,
     273acesso por índices e chamadas de funções.
     274
     275Note que ``{{ article.pub_date|date:"F j, Y" }}`` usa um "pipe" estilo Unix (o
     276caractere "|"). Isso é chamado filtro de template e é um modo de filtrar o valor
     277de uma variável. Nesse caso o filtro de data formata um objeto "datetime" do Python
     278no formato dado (como o usado na função "date" do PHP; sim, existe uma boa idéia
     279no PHP).
     280
     281Você pode encadear tantos filtros quanto você quiser. Você pode escrever seus próprios
     282filtros. Você pode escrever suas próprias "tags" de "template", que podem executar
     283código Python por trás das cortinas.
     284
     285Finalmente, o Django usa o conceito de "herança de templates": Isso é o que
     286``{% extends "base.html" %}`` faz. Significa "Primeiro carregue o template chamado
     287'base', que já definiu uma série de blocos, e preencha os blocos com os seguintes
     288blocos." Resumindo, isso permite que você diminua drasticamente a redundância dos
     289seus templates: Cada template define apenas o que é exclusivo dele próprio.
     290
     291Aqui está como o template "base.html" poderia se parecer::
     292
     293    <html>
     294    <head>
     295        <title>{% block title %}{% endblock %}</title>
     296    </head>
     297    <body>
     298        <img src="sitelogo.gif" alt="Logo" />
     299        {% block content %}{% endblock %}
     300    </body>
     301    </html>
     302
     303De maneira simplista, ele define a aparência geral do site (com o logo do site),
     304e provê alguns "buracos" para os templates filhos preencherem. Isso faz o "redesign"
     305de um site tão fácil quanto mudar um único arquivo -- o template base.
     306
     307Ele também permite que você crie múltiplas versões de um site, com templates
     308base diferentes, enquanto os templates filhos são reusados. Os criadores do
     309Django usaram essa técnica para criar edições para celular dos site extremamente
     310diferentes -- simplesmente criando um novo template base.
     311
     312Note que você não precisa usar o sistema de templates do Django se você prefere
     313outro sistema. Enquanto o sistema de templates do Django é particularmente bem
     314integrado com a camada de modelos do Django, nada força você a usá-lo. Falando
     315nisso, você também não precisa usar a API de banco de dados do Django. Você pode
     316usar outra camada de abstração de banco de dados, você pode ler arquivos XML, você
     317pode ler arquivos "off disk" (fora de um disco?) ou qualquer coisa que você
     318preferir. Cada parte do Django -- modelos, "views", "templates" -- é desacoplada
     319das outras.
     320
     321Essa é apenas a superfície
     322==========================
     323
     324Essa foi apenas uma rápida visão da funcionalidade que o Django oferece. Algumas
     325outras características úteis são:
     326
     327    * Um framework de "caching" que integra com o "memcached" e outros "backends".
     328    * Um framework de syndication que faz com que a criação de feeds RSS e Atom feeds
     329      seja tão fácil quanto escrever uma pequena classe Python.
     330    * Mais "features sexys" (fica meio estranho :P) para a interface de administração
     331      automática -- esse texto mostrou apenas a superfície.
     332   
     333Os próximos passos óbvios para você é `baixar o Django`_, ler `o tutorial` a
     334se juntar à `comunidade`_. Obrigado pelo seu interesse!
     335   
     336
     337.. _baixar o Django: http://www.djangoproject.com/download/
     338.. _o tutorial: http://www.djangoproject.com/documentation/tutorial1/
     339.. _comunidade: http://www.djangoproject.com/community/
     340
     341}}}
Back to Top