functions: DTML Functions
DTML utility functions provide some Python built-in functions and
some DTML-specific functions.
Functions
- abs(number)
- Return the absolute value of a number. The argument may
be a plain or long integer or a floating point number. If the argument
is a complex number, its magnitude is returned.
- chr(integer)
- Return a string of one character whose ASCII code
is the integer, e.g.,
chr(97) returns the string a. This is
the inverse of ord(). The argument must be in the range 0 to 255,
inclusive; ValueError will be raised if the integer is outside
that range.
- DateTime()
- Returns a Zope
DateTime object given constructor
arguments. See the DateTime API reference for more
information on constructor arguments.
- divmod(number, number)
- Take two numbers as arguments and return
a pair of numbers consisting of their quotient and remainder when
using long division. With mixed operand types, the rules for
binary arithmetic operators apply. For plain and long integers,
the result is the same as
(a / b, a % b). For floating point
numbers the result is (q, a % b), where q is usually
math.floor(a / b) but may be 1 less than that. In any case q *
b + a % b is very close to a, if a % b is non-zero it has the
same sign as b, and 0 <= abs(a % b) < abs(b).
- float(number)
- Convert a string or a number to floating
point. If the argument is a string, it must contain a possibly
signed decimal or floating point number, possibly embedded in
whitespace; this behaves identical to
string.atof(number). Otherwise, the argument may be a plain or
long integer or a floating point number, and a floating point
number with the same value (within Python's floating point
precision) is returned.
- getattr(object, string)
- Return the value of the named
attributed of object. name must be a string. If the string is the
name of one of the object's attributes, the result is the value of
that attribute. For example,
getattr(x, "foobar") is equivalent
to x.foobar. If the named attribute does not exist, default is
returned if provided, otherwise AttributeError is raised.
- getitem(variable, render=0)
- Returns the value of a DTML variable.
If
render is true, the variable is rendered. See the render
function.
- hasattr(object, string)
- The arguments are an object and a
string. The result is 1 if the string is the name of one of the
object's attributes, 0 if not. (This is implemented by calling
getattr(object, name) and seeing whether it raises an exception or
not.)
- hash(object)
- Return the hash value of the object (if it has
one). Hash values are integers. They are used to quickly compare
dictionary keys during a dictionary lookup. Numeric values that compare
equal have the same hash value (even if they are of different types,
e.g. 1 and 1.0).
- has_key(variable)
- Returns true if the DTML namespace contains the
named variable.
- hex(integer)
- Convert an integer number (of any size) to a
hexadecimal string. The result is a valid Python expression. Note: this
always yields an unsigned literal, e.g. on a 32-bit machine,
hex(-1)
yields 0xffffffff. When evaluated on a machine with the same word
size, this literal is evaluated as -1; at a different word size, it
may turn up as a large positive number or raise an OverflowError
exception.
- int(number)
- Convert a string or number to a plain integer. If
the argument is a string, it must contain a possibly signed
decimal number representable as a Python integer, possibly
embedded in whitespace; this behaves identical to
string.atoi(number[, radix]). The radix parameter gives the
base for the conversion and may be any integer in the range 2 to
36. If radix is specified and the number is not a string,
TypeError is raised. Otherwise, the argument may be a plain or
long integer or a floating point number. Conversion of floating
point numbers to integers is defined by the C semantics; normally
the conversion truncates towards zero.
- len(sequence)
- Return the length (the number of items) of an
object. The argument may be a sequence (string, tuple or list) or a
mapping (dictionary).
- max(s)
- With a single argument s, return the largest item of a
non-empty sequence (e.g., a string, tuple or list). With more than one
argument, return the largest of the arguments.
- min(s)
- With a single argument s, return the smallest item of
a non-empty sequence (e.g., a string, tuple or list). With more than
one argument, return the smallest of the arguments.
- namespace([name=value]...)
- Returns a new DTML namespace object.
Keyword argument
name=value pairs are pushed into the new
namespace.
- oct(integer)
- Convert an integer number (of any size) to an octal
string. The result is a valid Python expression. Note: this always
yields an unsigned literal, e.g. on a 32-bit machine,
oct(-1) yields
037777777777. When evaluated on a machine with the same word size,
this literal is evaluated as -1; at a different word size, it may
turn up as a large positive number or raise an OverflowError
exception.
- ord(character)
- Return the ASCII value of a string of one
character. E.g.,
ord("a") returns the integer 97. This is the
inverse of chr().
- pow(x, y [,z])
- Return x to the power y; if z is present,
return x to the power y, modulo z (computed more efficiently
than
pow(x, y) % z). The arguments must have numeric types. With
mixed operand types, the rules for binary arithmetic operators
apply. The effective operand type is also the type of the result;
if the result is not expressible in this type, the function raises
an exception; e.g., pow(2, -1) or pow(2, 35000) is not
allowed.
- range([start,] stop [,step])
- This is a versatile function to
create lists containing arithmetic progressions. The arguments
must be plain integers. If the step argument is omitted, it
defaults to 1. If the start argument is omitted, it defaults to
0. The full form returns a list of plain integers
[start, start
+ step, start + 2 * step, ...]. If step is positive, the last
element is the largest start + i * step less than stop; if
step is negative, the last element is the largest start + i *
step greater than stop. step must not be zero (or else
ValueError is raised).
- round(x [,n])
- Return the floating point value x rounded to n
digits after the decimal point. If n is omitted, it defaults to
zero. The result is a floating point number. Values are rounded to the
closest multiple of 10 to the power minus n; if two multiples are
equally close, rounding is done away from 0 (so e.g. round(0.5) is 1.0
and round(-0.5) is -1.0).
- render(object)
- Render
object. For DTML objects this
evaluates the DTML code with the current namespace. For other
objects, this is equivalent to str(object).
- reorder(s [,with] [,without])
- Reorder the items in s according
to the order given in
with and without the items mentioned in
without. Items from s not mentioned in with are removed. s,
with, and without are all either sequences of strings or
sequences of key-value tuples, with ordering done on the
keys. This function is useful for constructing ordered select
lists.
- SecurityCalledByExecutable()
- Return a true if the current
object (e.g. DTML document or method) is being called by an
executable (e.g. another DTML document or method, a script or a
SQL method).
- SecurityCheckPermission(permission, object)
- Check whether the
security context allows the given permission on the given
object. For example,
SecurityCheckPermission("Add Documents,
Images, and Files", this()) would return true if the current user
was authorized to create documents, images, and files in the
current location.
- SecurityGetUser()
- Return the current user object. This is
normally the same as the
REQUEST.AUTHENTICATED_USER
object. However, the AUTHENTICATED_USER object is insecure since
it can be replaced.
- SecurityValidate([object] [,parent] [,name] [,value])
- Return
true if the value is accessible to the current user.
object is
the object the value was accessed in, parent is the container of
the value, and name is the named used to access the value (for
example, if it was obtained via getattr). You may omit some of
the arguments, however it is best to provide all available
arguments.
- SecurityValidateValue(object)
- Return true if the object is
accessible to the current user. This function is the same as
calling
SecurityValidate(None, None, None, object).
- str(object)
- Return a string containing a nicely printable
representation of an object. For strings, this returns the string
itself.
- test(condition, result [,condition, result]... [,default])
- Takes one or more condition, result pairs and returns the result
of the first true condition. Only one result is returned, even if
more than one condition is true. If no condition is true and a
default is given, the default is returned. If no condition is true
and there is no default, None is returned.
- unichr(number)
- Return a unicode string representing the value of
number as a unicode character. This is the inverse of ord() for
unicode characters.
- unicode(string[, encoding[, errors ] ])
- Decodes string using the
codec for encoding. Error handling is done according to errors. The
default behavior is to decode UTF-8 in strict mode, meaning that
encoding errors raise ValueError.
Attributes
- None
- The
None object is equivalent to the Python built-in object
None. This is usually used to represent a Null or false value.
See Also
"string module":string.py
"random module":random.py
"math module":math.py
"sequence module":sequence.py
Built-in Python Functions