Standard type built-in functions in python
4.6. Standard Type Built-in FunctionsAlong with generic operators which we have just seen, Python also provides some built-in functions that can be applied to all the basic object types: cmp(), repr(), str(), type(), and the single reverse or back quotes ( '' ) operator, which is functionally-equivalent to repr(). Show
4.6.1. cmp()The cmp() built-in function CoMPares two objects, say, obj1 ... The Python interpreter has a number of functions and types built into it that are always available. They are listed here in alphabetical order.
abs (x)¶Return the absolute value of a number. The argument may be an integer, a floating point number, or an object implementing aiter (async_iterable)¶Return an asynchronous iterator for an asynchronous iterable.
Equivalent to calling Note: Unlike New in version 3.10. all (iterable)¶Return def all(iterable): for element in iterable: if not element: return False return Trueawaitable anext (async_iterator[,
default])¶When awaited, return the next item from the given asynchronous iterator, or default if given and the iterator is exhausted. This is the async variant of the
This calls the New in version 3.10. any (iterable)¶
Return def any(iterable): for element in iterable: if element: return True return False ascii (object)¶As bin (x)¶Convert an integer number to a binary string prefixed with “0b”. The result is a valid Python expression. If x is not a Python >>> bin(3) '0b11' >>> bin(-10) '-0b1010' If the prefix “0b” is desired or not, you can use either of the following ways. >>> format(14, '#b'), format(14, 'b') ('0b1110', '1110') >>> f'{14:#b}', f'{14:b}' ('0b1110', '1110') See also bool ([x])¶Return a Boolean value, i.e. one of Changed in version 3.7: x is now a positional-only parameter. breakpoint (*args,
**kws)¶This function drops you into the debugger at the call site. Specifically, it calls Raises an auditing event New in version 3.7. classbytearray ([source[,
encoding[, errors]]])Return a new array of bytes. The The optional source parameter can be used to initialize the array in a few different ways:
Without an argument, an array of size 0 is created. See also Binary Sequence Types — bytes, bytearray, memoryview and Bytearray Objects. classbytes ([source[, encoding[,
errors]]])Return a new “bytes” object which is an immutable sequence of integers in the range Accordingly, constructor arguments are interpreted as for Bytes objects can also be created with literals, see String and Bytes literals. See also Binary Sequence Types — bytes, bytearray, memoryview, Bytes Objects, and Bytes and Bytearray Operations. callable (object)¶Return New in version 3.2: This function was first removed in Python 3.0 and then brought back in Python 3.2. chr (i)¶Return the string representing a character whose
Unicode code point is the integer i. For example, The valid range for the argument is from 0 through 1,114,111 (0x10FFFF in base 16). @ classmethod ¶Transform a method into a class method. A class method receives the class as an implicit first argument, just like an instance method receives the instance. To declare a class method, use this idiom: class C: @classmethod def f(cls, arg1, arg2): ... The A class method can be called either on the class (such as Class methods are different than C++ or Java static methods. If you want those, see Changed in version 3.9: Class methods can now wrap
other descriptors such as Changed in version 3.10: Class methods now inherit the method attributes ( compile (source, filename, mode, flags=0, dont_inherit=False, optimize=- 1)¶Compile the source into a code
or AST object. Code objects can be executed by The filename argument should give the file from which the code was read; pass some recognizable value if it wasn’t read from a file ( The mode argument specifies what kind of code must be compiled;
it can be The optional arguments flags and dont_inherit control which compiler options
should be activated and which future features should be allowed. If neither is present (or both are zero) the code is compiled with the same flags that affect the code that is calling Compiler options and future statements are specified by bits which can be bitwise ORed together to specify multiple options. The bitfield required to specify a given future
feature can be found as the The argument optimize specifies the optimization level of the compiler; the default value of This function raises If you want to parse Python code into its AST representation, see
Raises an auditing event Note When compiling a string with multi-line code in Warning It is possible to crash the Python interpreter with a sufficiently large/complex string when compiling to an AST object due to stack depth limitations in Python’s AST compiler. Changed in version 3.2: Allowed
use of Windows and Mac newlines. Also, input in Changed in version 3.5: Previously, New in version 3.8: complex ([real[, imag]])¶Return a complex number with the value real + imag*1j or convert a string or number to a complex number. If the
first parameter is a string, it will be interpreted as a complex number and the function must be called without a second parameter. The second parameter can never be a string. Each argument may be any numeric type (including complex). If imag is omitted, it defaults to zero and the constructor serves as a numeric conversion like For a general Python object Note When converting from a string, the string must not contain whitespace around the central The complex type is described in Numeric Types — int, float, complex. Changed in version 3.6: Grouping digits with underscores as in code literals is allowed. Changed in version 3.8:
Falls back to delattr (object, name)¶This is a relative of dict (**kwarg) class dict (mapping, **kwarg) class dict (iterable, **kwarg)Create a new dictionary. The
For other containers see the built-in
dir ([object])¶Without arguments, return the list of names in the current local scope. With an argument, attempt to return a list of valid attributes for that object. If the object has a method named If the object does not provide The default
The resulting list is sorted alphabetically. For example: >>> import struct >>> dir() # show the names in the module namespace ['__builtins__', '__name__', 'struct'] >>> dir(struct) # show the names in the struct module ['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__initializing__', '__loader__', '__name__', '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into', 'unpack', 'unpack_from'] >>> class Shape: ... def __dir__(self): ... return ['area', 'perimeter', 'location'] >>> s = Shape() >>> dir(s) ['area', 'location', 'perimeter'] Note Because
divmod (a, b)¶Take two (non-complex) numbers as arguments and return a pair of numbers consisting of their quotient and remainder when using integer division. With mixed operand types, the rules for binary arithmetic operators apply. For integers, the result is the same as enumerate (iterable,
start=0)¶Return an enumerate object. iterable must be a sequence, an iterator, or some other object which supports iteration. The
>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter'] >>> list(enumerate(seasons)) [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')] >>> list(enumerate(seasons, start=1)) [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')] Equivalent to: def enumerate(sequence, start=0): n = start for elem in sequence: yield n, elem n += 1 eval (expression[, globals[, locals]])¶The arguments are a string and optional globals and locals. If provided, globals must be a dictionary. If provided, locals can be any mapping object. The expression argument is
parsed and evaluated as a Python expression (technically speaking, a condition list) using the globals and locals dictionaries as global and local namespace. If the globals dictionary is present and does not contain a value for the key The return value is the result of the evaluated expression. Syntax errors are reported as exceptions. Example: >>> x = 1 >>> eval('x+1') 2 This function can also be used to execute arbitrary code objects (such as those created by Hints: dynamic execution of statements is supported by the If the given source is a string, then leading and trailing spaces and tabs are stripped. See Raises an auditing event exec (object[, globals[,
locals]])¶This function supports dynamic execution of Python code. object must be either a string or a code object. If it is a string, the string is parsed as a suite of Python statements which is then executed (unless a syntax error occurs).
1 If it is a code object, it is simply executed. In all cases, the code that’s executed is expected to be valid as file input (see the section File input in the Reference Manual). Be aware that the
In all cases, if the optional parts are omitted, the code is executed in the current scope. If only globals is provided, it must be a dictionary (and not a subclass of dictionary), which will be used for both the global and the local variables. If globals and locals are given, they are used for the global and local variables, respectively. If provided, locals can be any mapping object. Remember that at the module level, globals and locals are the same dictionary. If exec gets two separate objects as globals and locals, the code will be executed as if it were embedded in a class definition. If the globals dictionary does not contain a value for the key Raises an auditing event Note The built-in functions Note The default locals act as described for function filter (function, iterable)¶Construct
an iterator from those elements of iterable for which function returns true. iterable may be either a sequence, a container which supports iteration, or an iterator. If function is Note that See
float ([x])¶Return a floating point number constructed from a number or string x. If the argument is a string, it should contain a decimal number, optionally preceded by a sign, and optionally embedded in whitespace. The optional sign may be sign ::= "+" | "-" infinity ::= "Infinity" | "inf" nan ::= "nan" numeric_value ::= Here Otherwise, if the argument is an integer or a floating point number, a floating point number with the same value (within Python’s floating point precision) is returned. If the argument is outside the range of a Python float,
an For a general Python object If no argument is given, Examples: >>> float('+1.23') 1.23 >>> float(' -12345\n') -12345.0 >>> float('1e-003') 0.001 >>> float('+1E6') 1000000.0 >>> float('-Infinity') -inf The float type is described in Numeric Types — int, float, complex. Changed in version 3.6: Grouping digits with underscores as in code literals is allowed. Changed in version 3.7: x is now a positional-only parameter. Changed in version 3.8: Falls back to format (value[, format_spec])¶Convert a value to a “formatted” representation, as controlled by format_spec. The interpretation of format_spec will depend on the type of the value argument; however, there is a standard formatting syntax that is used by most built-in types: Format Specification Mini-Language. The default format_spec is an empty string which usually gives the same effect as calling A call to Changed in version 3.4: frozenset ([iterable])Return a new For other containers see the built-in getattr (object, name[, default])¶Return the value of the named attribute 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,
Note Since
private name mangling happens at compilation time, one must manually mangle a private attribute’s (attributes with two leading underscores) name in order to retrieve it with globals ()¶Return the dictionary implementing the current module namespace. For code within functions, this is set when the function is defined and remains the same regardless of where the function is called. hasattr (object,
name)¶The arguments are an object and a string. The result is 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, as is the case for 1 and 1.0). Note For objects with custom help ([object])¶Invoke the built-in help system. (This function is intended for interactive use.) If no argument is given, the interactive help system starts on the interpreter console. If the argument is a string, then the string is looked up as the name of a module, function, class, method, keyword, or documentation topic, and a help page is printed on the console. If the argument is any other kind of object, a help page on the object is generated. Note that if a slash(/) appears in the parameter list of a function when invoking This function is added to the built-in namespace by the Changed in version 3.4: Changes to
hex (x)¶Convert an integer number to a lowercase hexadecimal string prefixed with “0x”. If x is not a Python >>> hex(255) '0xff' >>> hex(-42) '-0x2a' If you want to convert an integer number to an uppercase or lower hexadecimal string with prefix or not, you can use either of the following ways: >>> '%#x' % 255, '%x' % 255, '%X' % 255 ('0xff', 'ff', 'FF') >>> format(255, '#x'), format(255, 'x'), format(255, 'X') ('0xff', 'ff', 'FF') >>> f'{255:#x}', f'{255:x}', f'{255:X}' ('0xff', 'ff', 'FF') See also See also Note To obtain a hexadecimal string representation for a float, use the id (object)¶Return the “identity” of an
object. This is an integer which is guaranteed to be unique and constant for this object during its lifetime. Two objects with non-overlapping lifetimes may have the same CPython implementation detail: This is the address of the object in memory. Raises an auditing
event input ([prompt])¶If the prompt argument is present, it is written to standard output without a trailing newline. The function then reads a line from input, converts it to a string (stripping a trailing newline),
and returns that. When EOF is read, >>> s = input('--> ') --> Monty Python's Flying Circus >>> s "Monty Python's Flying Circus" If the Raises an auditing event Raises an auditing event int ([x])¶ class int (x, base=10)Return an integer object constructed from a number or string x, or return If x is not a number or if base is given, then x must be a string, The integer type is described in Numeric Types — int, float, complex. Changed in version 3.4: If base is not an instance of Changed in version 3.6: Grouping digits with underscores as in code literals is allowed. Changed in version 3.7: x is now a positional-only parameter. Changed in version 3.8: Falls back to Changed in version 3.10.7: isinstance (object, classinfo)¶Return Changed in version 3.10: classinfo can be a Union Type. issubclass (class, classinfo)¶Return Changed in version 3.10: classinfo can be a Union Type. iter (object[, sentinel])¶Return an
iterator object. The first argument is interpreted very differently depending on the presence of the second argument. Without a second argument, object must be a collection object which supports the iterable protocol (the See also Iterator Types. One useful application of the second form of from functools import partial with open('mydata.db', 'rb') as f: for block in iter(partial(f.read, 64), b''): process_block(block) len (s)¶Return the length (the number of items) of an object. The argument may be a sequence (such as a string, bytes, tuple, list, or range) or a collection (such as a dictionary, set, or frozen set). classlist ([iterable])Rather than being a function, locals ()¶Update and return a dictionary representing the current local symbol table. Free variables are returned by
Note The contents of this dictionary should not be modified; changes may not affect the values of local and free variables used by the interpreter. map (function, iterable, ...)¶Return an iterator that applies function to every item of iterable, yielding the results. If additional
iterable arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel. With multiple iterables, the iterator stops when the shortest iterable is exhausted. For cases where the function inputs are already arranged into argument tuples, see max (iterable, *[, key, default])¶ max (arg1, arg2, *args[, key])Return the largest item in an iterable or the largest of two or more arguments. If one positional argument is provided, it should be an iterable. The largest item in the iterable is returned. If two or more positional arguments are provided, the largest of the positional arguments is returned. There are two optional keyword-only arguments. The key argument specifies a one-argument ordering function like that used for
If multiple items are maximal, the function returns the first one encountered. This is
consistent with other sort-stability preserving tools such as New in version 3.4: The default keyword-only argument. Changed in version 3.8: The key can be memoryview (object)Return a “memory view” object created from the given argument. See Memory Views for more information. min (iterable, *[, key, default])¶ min (arg1, arg2,
*args[, key])Return the smallest item in an iterable or the smallest of two or more arguments. If one positional argument is provided, it should be an iterable. The smallest item in the iterable is returned. If two or more positional arguments are provided, the smallest of the positional arguments is returned. There are
two optional keyword-only arguments. The key argument specifies a one-argument ordering function like that used for If multiple items are minimal, the function returns the first one encountered. This is consistent with other sort-stability preserving tools such as New in version 3.4: The default keyword-only argument. Changed in version 3.8: The key can be next (iterator[, default])¶Retrieve the next item from the iterator by calling its
object ¶Return a new featureless object. Note
oct (x)¶Convert an integer number to an octal string prefixed with “0o”. The result is a valid Python expression. If x is not a Python >>> oct(8) '0o10' >>> oct(-56) '-0o70' If you want to convert an integer number to an octal string either with the prefix “0o” or not, you can use either of the following ways. >>> '%#o' % 10, '%o' % 10 ('0o12', '12') >>> format(10, '#o'), format(10, 'o') ('0o12', '12') >>> f'{10:#o}', f'{10:o}' ('0o12', '12') See also open (file, mode='r', buffering=- 1, encoding=None,
errors=None, newline=None, closefd=True, opener=None)¶Open file and return a corresponding
file object. If the file cannot be opened, an file is a
path-like object giving the pathname (absolute or relative to the current working directory) of the file to be opened or an integer file descriptor of the file to be wrapped. (If a file descriptor is given, it is closed when the returned I/O object is closed unless closefd is set to mode is an optional string that specifies the mode in which the file is
opened. It defaults to
The default mode is As mentioned in the Overview, Python distinguishes between binary and text I/O. Files opened in binary mode (including There is an additional mode character permitted, Note Python doesn’t depend on the underlying operating system’s notion of text files; all the processing is done by Python itself, and is therefore platform-independent. buffering is an optional integer used to set the buffering policy. Pass 0 to switch buffering off (only allowed in binary mode), 1 to
select line buffering (only usable in text mode), and an integer > 1 to indicate the size in bytes of a fixed-size chunk buffer. Note that specifying a buffer size this way applies for binary buffered I/O, but
encoding is the name of the encoding used to decode or encode the file. This should only be used in text mode. The default encoding is platform dependent (whatever errors is an optional string that specifies how encoding and decoding errors are to be handled—this cannot be used in binary mode. A variety of standard error handlers are available (listed under
Error Handlers), though any error handling name that has been registered with
newline controls how universal newlines mode works (it only applies to text mode). It can be
If closefd is A custom opener can be used by passing a callable as opener. The underlying file descriptor for the file object is then obtained by calling opener with (file, flags).
opener must return an open file descriptor (passing The newly created file is non-inheritable. The following example uses the
dir_fd parameter of the >>> import os >>> dir_fd = os.open('somedir', os.O_RDONLY) >>> def opener(path, flags): ... return os.open(path, flags, dir_fd=dir_fd) ... >>> with open('spamspam.txt', 'w', opener=opener) as f: ... print('This will be written to somedir/spamspam.txt', file=f) ... >>> os.close(dir_fd) # don't leak a file descriptor The type of file object returned by the
See also the file handling modules, such as
Raises an auditing event The
Deprecated since version 3.4, removed in version 3.10: The
ord (c)¶Given
a string representing one Unicode character, return an integer representing the Unicode code point of that character. For example, pow (base, exp[,
mod])¶Return base to the power exp; if mod is present, return base to the power exp, modulo mod (computed more efficiently than The arguments must have numeric types. With mixed
operand types, the coercion rules for binary arithmetic operators apply. For For Here’s an example of computing an inverse for >>> pow(38, -1, mod=97) 23 >>> 23 * 38 % 97 == 1 True Changed in version 3.8: For
Changed in version 3.8: Allow keyword arguments. Formerly, only positional arguments were supported. print (*objects,
sep=' ', end='\n', file=sys.stdout, flush=False)¶Print objects to the text stream file, separated by sep and followed by end. sep, end, file, and flush, if present, must be given as keyword arguments. All non-keyword arguments are converted to strings like The file argument must be an object with a Whether the output is buffered is usually determined by file, but if the flush keyword argument is true, the stream is forcibly flushed. Changed in version 3.3: Added the flush keyword argument. classproperty (fget=None, fset=None, fdel=None, doc=None)¶Return a property attribute. fget is a function for getting an attribute value. fset is a function for setting an attribute value. fdel is a function for deleting an attribute value. And doc creates a docstring for the attribute. A typical use is to define a managed attribute class C: def __init__(self): self._x = None def getx(self): return self._x def setx(self, value): self._x = value def delx(self): del self._x x = property(getx, setx, delx, "I'm the 'x' property.") If c is an instance of C, If given, doc will be the docstring of the property attribute.
Otherwise, the property will copy fget’s docstring (if it exists). This makes it possible to create read-only properties easily using class Parrot: def __init__(self): self._voltage = 100000 @property def voltage(self): """Get the current voltage.""" return self._voltage The A property object has class C: def __init__(self): self._x = None @property def x(self): """I'm the 'x' property.""" return self._x @x.setter def x(self, value): self._x = value @x.deleter def x(self): del self._x This code is exactly equivalent to the first example. Be sure to give the additional functions the same name as the original property ( The returned property object also has the attributes Changed in version 3.5: The docstrings of property objects are now writeable. classrange (stop) class range (start, stop[,
step])Rather than being a function, repr (object)¶Return a string containing a printable representation of an object. For many types, this function makes an attempt to return a string that would yield an object with the same value when passed to
reversed (seq)¶Return a reverse iterator. seq must be an object which has a round (number[, ndigits])¶Return number rounded to ndigits precision after the decimal point. If ndigits is omitted or is For the built-in types
supporting For a general Python object Note The behavior of set ([iterable])Return a new For other containers see the built-in
setattr (object, name, value)¶This is the counterpart of
name need not be a Python identifier as defined in
Identifiers and keywords unless the object chooses to enforce that, for example in a custom Note Since private name mangling happens at compilation time, one must manually mangle a private attribute’s (attributes with two
leading underscores) name in order to set it with slice (stop)¶ class slice (start, stop[,
step])Return a slice object representing the set of indices specified by sorted (iterable, /, *,
key=None, reverse=False)¶Return a new sorted list from the items in iterable. Has two optional arguments which must be specified as keyword arguments. key specifies a function of one argument that is used to extract a
comparison key from each element in iterable (for example, reverse is a boolean value. If set to Use The built-in The sort algorithm uses only For sorting examples and a brief sorting tutorial, see Sorting HOW TO. @ staticmethod ¶Transform a method into a static method. A static method does not receive an implicit first argument. To declare a static method, use this idiom: class C: @staticmethod def f(arg1, arg2, ...): ... The
A static method can be called either on the class (such as Static methods in Python are similar to those found in Java or C++. Also, see Like all decorators, it is also possible to call def regular_function(): ... class C: method = staticmethod(regular_function) For more information on static methods, see The standard type hierarchy. Changed in version 3.10: Static methods now inherit the method attributes ( str (object='') class str (object=b'', encoding='utf-8', errors='strict')Return a
sum (iterable, /, start=0)¶Sums start and the items of an iterable from left to right and returns the total. The iterable’s items are normally numbers, and the start value is not allowed to be a string. For some use cases, there are good alternatives to Changed in version 3.8: The start parameter can be specified as a keyword argument. classsuper ([type[, object-or-type]])¶Return a proxy object that delegates method calls to a parent or sibling class of type. This is useful for accessing inherited methods that have been overridden in a class. The object-or-type determines the method resolution order to be searched. The search starts from the class right after the type. For example, if The If the second argument is omitted, the super object returned is unbound. If the second argument is an object, There are two typical use cases for super. In a class hierarchy with single inheritance, super can be used to refer to parent classes without naming them explicitly, thus making the code more maintainable. This use closely parallels the use of super in other programming languages. The second use case is to support cooperative multiple inheritance in a dynamic execution environment. This use case is unique to Python and is not found in statically compiled languages or languages that only support single inheritance. This makes it possible to implement “diamond diagrams” where multiple base classes implement the same method. Good design dictates that such implementations have the same calling signature in every case (because the order of calls is determined at runtime, because that order adapts to changes in the class hierarchy, and because that order can include sibling classes that are unknown prior to runtime). For both use cases, a typical superclass call looks like this: class C(B): def method(self, arg): super().method(arg) # This does the same thing as: # super(C, self).method(arg) In addition
to method lookups, Note that Also note that, aside from the zero argument form,
For practical suggestions on how to
design cooperative classes using tuple ([iterable])Rather than being a function,
type (object)¶ class type (name, bases, dict, **kwds)With one argument, return the type of an object. The return value is a type
object and generally the same object as returned by The With three arguments, return a new type object. This is essentially a
dynamic form of the >>> class X: ... a = 1 ... >>> X = type('X', (), dict(a=1)) See also Type Objects. Keyword arguments provided to the
three argument form are passed to the appropriate metaclass machinery (usually See also Customizing class creation. Changed in
version 3.6: Subclasses of vars ([object])¶Return the Objects such as modules and instances have an updateable
Without an argument, A zip (*iterables, strict=False)¶Iterate over several iterables in parallel, producing tuples with an item from each one. Example: >>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']): ... print(item) ... (1, 'sugar') (2, 'spice') (3, 'everything nice') More formally: Another way to think of
One thing to
consider is that the iterables passed to
Edge cases: With a single iterable argument,
Tips and tricks:
Changed in version 3.10: Added the __import__ (name, globals=None, locals=None, fromlist=(), level=0)¶This function
is invoked by the The function imports the module name, potentially using the given globals and locals to determine how to interpret the name in a package context. The fromlist gives the names of objects or submodules that should be imported from the module given by name. The standard implementation does not use its
locals argument at all and uses its globals only to determine the package context of the level specifies whether to use absolute or relative imports. When the name variable is of the form For example, the statement spam = __import__('spam', globals(), locals(), [], 0) The statement spam = __import__('spam.ham', globals(), locals(), [], 0) Note how On the other hand, the statement _temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0) eggs = _temp.eggs saus = _temp.sausage Here, the If you simply want to import a module
(potentially within a package) by name, use Changed in version 3.3: Negative values for level are no longer supported (which also changes the default value to 0). Changed in version 3.9: When the command line options
Footnotes 1Note that the parser only accepts the Unix-style end of line convention. If you are reading the code from a file, make sure to use newline conversion mode to convert Windows or Mac-style newlines. What are standard built in functions?4.6. Standard Type Built-in Functions. What is standard function in Python?Python Built in Functions. What are the built in Python types?The principal built-in types are numerics, sequences, mappings, classes, instances and exceptions. Some collection classes are mutable. The methods that add, subtract, or rearrange their members in place, and don't return a specific item, never return the collection instance itself but None .
What are the types of built in functions?Built-in functions. Standard built-in functions.. Aggregates (set functions). ABS or ABSVAL function.. ACOS function. The ACOS function returns the arc cosine of a specified number.. ASIN function. The ASIN function returns the arc sine of a specified number.. ATAN function. ... . ATAN2 function. ... . AVG function.. |