Login With Github

Language Reference: Expressions (TALES)

The Template Attribute Language Expression Syntax (TALES) standard describes expressions that supply Basics (TAL) and Macros (METAL) with data. TALES is one possible expression syntax for these languages, but they are not bound to this definition. Similarly, TALES could be used in a context having nothing to do with TAL or METAL.

TALES expressions are described below with any delimiter or quote markup from higher language layers removed. Here is the basic definition of TALES syntax:

Expression  ::= [type_prefix ':'] String
type_prefix ::= Name

Here are some simple examples:

1 + 2
string:Hello, ${view.user_name}

The optional type prefix determines the semantics and syntax of the expression string that follows it. A given implementation of TALES can define any number of expression types, with whatever syntax you like. It also determines which expression type is indicated by omitting the prefix.


These are the available TALES expression types:

Prefix Description
exists Evaluate the result inside an exception handler; if one of the exceptions AttributeErrorLookupErrorTypeErrorNameError, or KeyError is raised during evaluation, the result is False, otherwise True. Note that the original result is discarded in any case.
import Import a global symbol using dotted notation.
load Load a template relative to the current template or absolute.
not Negate the expression result
python Evaluate a Python expression
string Format a string
structure Wraps the expression result as structure.

Note: The default expression type is python.

Warning: The Zope reference engine defaults to a path expression type, which is closely tied to the Zope framework. This expression is not implemented in Chameleon (but it's available in a Zope framework compatibility package, z3c.pt).

There's a mechanism to allow fallback to alternative expressions, if one should fail (raise an exception). The pipe character ('|') is used to separate two expressions:

<div tal:define="page request.GET['page'] | 0">

This mechanism applies only to the python expression type, and by derivation string.


Evaluates a Python expression.


Python expression syntax:

Any valid Python language expression


Python expressions are executed natively within the translated template source code. There is no built-in security apparatus.



String expression syntax:

string_expression ::= ( plain_string | [ varsub ] )*
varsub            ::= ( '$' Variable ) | ( '${ Expression }' )
plain_string      ::= ( '$$' | non_dollar )*
non_dollar        ::= any character except '$'


String expressions interpret the expression string as text. If no expression string is supplied the resulting string is empty. The string can contain variable substitutions of the form $name or${expression}, where name is a variable name, and expression is a TALES-expression. The escaped string value of the expression is inserted into the string.

Note: To prevent a $ from being interpreted this way, it must be escaped as $$.


Basic string formatting:

<span tal:replace="string:$this and $that">
  Spam and Eggs

<p tal:content="string:${request.form['total']}">
  total: 12

Including a dollar sign:

<p tal:content="string:$$$cost">
  cost: $42.00


Imports a module global.


Wraps the expression result as structure: The replacement text is inserted into the document without escaping, allowing HTML/XML markup to be inserted. This can break your page if the text contains unanticipated markup (eg. text submitted via a web form), which is the reason that it is not the default.


Loads a template instance.


Load expression syntax:

Relative or absolute file path


The template will be loaded using the same template class as the calling template.


Loading a template and using it as a macro:

<div tal:define="master load: ../master.pt" metal:use-macro="master" />

Built-in names

These are the names always available in the TALES expression namespace:

  • default - special value used to specify that existing text or attributes should not be replaced. See the documentation for individual TAL statements for details on how they interpret default.
  • repeat - the repeat variables; see tal:repeat for more information.
  • template - reference to the template which was first called; this symbol is carried over when using macros.
  • macros - reference to the macros dictionary that corresponds to the current template.

0 Comment