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