<Effective Django>读书笔记

1. In Django parlance, a project is the final product, and it assembles one
   or more applications together.


2. Manage.py is a pointer back to Django-admin.py with an environment
   variable set, pointing to your project as the one to read settings from and
   operate on when needed


3. Settings.py is where you’ll configure your project. It has a few sensible
   defaults, but no database chosen when you start.


4. Urls.py contains the URL to view mappings.


5. Wsgi.py is a WSGI wrapper for your application.


6. Beginning in Django 1.4, apps are placed alongside project packages.


7. Models.py will contain the Django ORM models for your app.


8. Views.py will contain the View code


9. Tests.py will contain the unit and integration tests you write


10. Django models map to a database table, and provide a place to encapsulate
    business logic. All models subclass the base Model


11. The INSTALLED_APPS setting lists the applications that the project uses.
    These are listed as strings that map to Python packages. Django will import
    each and looks for a models there.


12. By default Django will name your tables using a combination of the
    application name and model name.


13. Django adds an id field as the primary key for your model, unless you
    specify a primary key.


14. The syncdb manage command creates the tables in your database from
    models.


15. The model Manager allows you to operate on the collection of instanes:
    querying, creating, etc


16. Write unit tests for methods you add to the model


17. The test manage command runs the unit tests.


18. Django Views take an HTTP Request and return an HTTP Response to the
    user.


19. Any Python callable can be a view. The only hard and fast requirement is
    that it takes the request object (customarily named request) as its first
    argument.


20. Generic Views have always provided some basic functionality: render a
    template, redirect, create or edit a model.


21. The URL configuration tells Django how to match a request’s path to your
    Python code. Django looks for the URL configuration, defined as urlpatterns,
    in the urls.py file in your project.


22. By default Django will look for templates in applications, as well as in
    directories you specify in settings.TEMPLATE_DIRS.


23. Most generic views that do form processing have the concept of the
    “success URL”: where to redirect the user when the form is successfully
    submitted.


24. The collection of values available to a template when it’s rendered is
    referred to as the Context. The Context is a combination of information
    supplied by the view and information from context processors


25. Django has two tools that are helpful for writing unit tests for views:
    the Test Client and the RequestFactory


26. The TestClient takes a URL to retrieve, and resolves it against your
    project’s URL configuration. It then creates a test request, and passes that
    request through your view, returning the Response.


27. Django supports adding static files at both the application and project
    level. Where you add them sort of depends on how tied to your specific
    assembly of apps they are.


28. App specific static files are stored in the static subdirectory within the
    app. Django will also look in any directories listed in the STATIFFILES_DIRS
    setting.


29. Django distinguishes between static site files, and user upload
    media.


30. The staticfiles app is included to help manage static files and serve them
    during development.


31. Static files can be included with apps, or with the project.


32. Templates can extend one another, using block tags.


33. A Django Form is responsible for taking some user input, validating it,
    and turning it into Python objects.


34. Initial is a dictionary of values that will be used as the default values
    for an unbound form


35. Forms have two different phases of validation: field and form. All the
    fields are validated and converted to Python objects (if possible) before form
    validation begins.


36. Form validation takes place in a form’s clean() method


37. Forms take user input, validate it, and convert it to Python objects.


38. Django provides 3 types of fields for relating objects to each other:
    ForeignKey for creating one to many relationships, ManyToManyField for
    relating many to many, and OneToOneField for creating a one to one
    relationship.


39. A FormSet is an object that manages multiple copies of the same Form(or
    ModelForm) in a single page.

<Effective Django>读书笔记