As template files aresometimes written by designers or front-end developers, it can be difficult tohandle increasing complexity.

    Some general good practices apply to the part of the application passingdynamic content to the template engine, and to the templates themselves.

    • Template files should be passed only the dynamiccontent that is needed for rendering the template. Avoidthe temptation to pass additional content “just in case”:it is easier to add some missing variable when needed than to removea likely unused variable later.
    • Many template engines allow for complex statementsor assignments in the template itself, and manyallow some Python code to be evaluated in thetemplates. This convenience can lead to uncontrolledincrease in complexity, and often make it harder to find bugs.
    • It is often necessary to mix JavaScript templates withHTML templates. A sane approach to this design is to isolatethe parts where the HTML template passes some variable contentto the JavaScript code.

    is a very well-regarded template engine.

    It uses a text-based template language and can thus be used to generate anytype of markup, not just HTML. It allows customization of filters, tags, tests,and globals. It features many improvements over Django’s templating system.

    Here some important HTML tags in Jinja2:

    The next listings are an example of a web site in combination with the Tornadoweb server. Tornado is not very complicated to use.

    1. # import Jinja2
    2. from jinja2 import Environment, FileSystemLoader
    3.  
    4. # import Tornado
    5. import tornado.ioloop
    6. import tornado.web
    7.  
    8. # Load template file templates/site.html
    9. TEMPLATE_FILE = "site.html"
    10. templateLoader = FileSystemLoader( searchpath="templates/" )
    11. templateEnv = Environment( loader=templateLoader )
    12. template = templateEnv.get_template(TEMPLATE_FILE)
    13.  
    14. # List for famous movie rendering
    15. movie_list = [[1,"The Hitchhiker's Guide to the Galaxy"],[2,"Back to future"],[3,"Matrix"]]
    16.  
    17. html_output = template.render(list=movie_list,
    18.                         title="Here is my favorite movie list")
    19.  
    20. # Handler for main page
    21. class MainHandler(tornado.web.RequestHandler):
    22.     def get(self):
    23.         # Returns rendered template string to the browser request
    24.         self.write(html_output)
    25.  
    26. # Assign handler to the server root  (127.0.0.1:PORT/)
    27. application = tornado.web.Application([
    28.     (r"/", MainHandler),
    29. ])
    30. PORT=8884
    31. if __name__ == "__main__":
    32.     # Setup the server
    33.     application.listen(PORT)
    34.     tornado.ioloop.IOLoop.instance().start()

    The next listing is our site page () loaded in the Pythonapp which extends . The content block is automatically setinto the corresponding block in the page.

    1. {% extends "base.html" %}
    2. {% block content %}
    3.     <p class="important">
    4.     <div id="content">
    5.         <p>{{ list_title }}</p>
    6.         <ul>
    7.              {% for item in list %}
    8.              <li>{{ item[0]}} :  {{ item[1]}}</li>
    9.              {% endfor %}
    10.         </ul>
    11.     </div>
    12.     </p>
    13. {% endblock %}

    Jinja2 is the recommended templating library for new Python web applications.

    Chameleon Page Templates are an HTML/XML templateengine implementation of the ,TAL Expression Syntax (TALES),and syntaxes.

    Chameleon is available for Python 2.5 and up (including 3.x and PyPy), andis commonly used by the Pyramid Framework.

    Page Templates add within your document structure special element attributesand text markup. Using a set of simple language constructs, you control thedocument flow, element repetition, text replacement, and translation. Becauseof the attribute-based syntax, unrendered page templates are valid HTML and canbe viewed in a browser and even edited in WYSIWYG editors. This can makeround-trip collaboration with designers and prototyping with static files in abrowser easier.

    The basic TAL language is simple enough to grasp from an example:

    1. <html>
    2.   <body>
    3.     <h1>Hello, ${world}!</h1>
    4.     <table>
    5.       <tr tal:repeat="row 'apple', 'banana', 'pineapple'">
    6.         <td tal:repeat="col 'juice', 'muffin', 'pie'">
    7.            ${row.capitalize()} ${col}
    8.         </td>
    9.       </tr>
    10.     </table>
    11.   </body>
    12. </html>

    But keep in mind that the full _<span tal:replace=”expression”>Default Text</span>_syntax also allows for default content in the unrendered template.

    Being from the Pyramid world, Chameleon is not widely used.

    is a template language that compiles to Pythonfor maximum performance. Its syntax and API are borrowed from the best parts of othertemplating languages like Django and Jinja2 templates. It is the default templatelanguage included with the Pylons and Pyramid webframeworks.

    An example template in Mako looks like:

    To render a very basic template, you can do the following:

    1. from mako.template import Template

    Mako is well respected within the Python web community.