### 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