10.1 Built-in Functions

abs(x)

Returns the absolute value of x.

all(s)

Returns True if all of the values in the iterable s evaluate as True. Returns True if s is empty.

any(s)

Returns True if any of the values in the iterable s evaluate as True. Returns False if s is empty.

ascii(x)

Creates a printable representation of the object x just like the repr(), but only uses ASCII characters in the result. Non-ASCII characters are turned into appropriate escape sequences. This can be used to view Unicode strings in a terminal or shell that doesn’t support Unicode.

bin(x)

Returns a string with the binary representation of the integer x.

bool([x])

Type representing Boolean values True and False. If used to convert x, it returns True if x evaluates to true using the usual truth-testing semantics—that is, nonzero number, nonempty list, and so on. Otherwise, False is returned. False is also the default value returned if bool() is called without any arguments. The bool class inherits from int so the Boolean values True and False can be used as integers with values 1 and 0 in mathematical calculations.

breakpoint()

Sets a manual debugger breakpoint. When encountered, control will transfer to pdb, the Python debugger.

bytearray([x])

A type representing a mutable array of bytes. When creating an instance, x may either be an iterable sequence of integers in the range 0 to 255, an 8-bit string or bytes literal, or an integer that specifies the size of the byte array (in which case every entry will be initialized to 0).

bytearray(s ,encoding)

An alternative calling convention for creating a bytearray instance from characters in a string s where encoding specifies the character encoding to use in the conversion.

bytes([x])

A type representing an immutable array of bytes.

bytes(s, encoding)

An alternate calling convention for creating bytes from a string s where encoding specifies the encoding to use in conversion.

Table 10.1 shows operations supported by both bytes and byte arrays.

Byte arrays additionally support the methods in Table 10.2.

callable(obj)

Returns True if obj is callable as a function.

chr(x)

Converts the integer x representing a Unicode code-point into a single-character string.

classmethod(func)

This decorator creates a class method for the function func. It is typically only used inside class definitions where it is implicitly invoked using @classmethod. Unlike a normal method, a class method receives the class as the first argument, not an instance.

compile(string, filename, kind)

Compiles string into a code object for use with exec() or eval(). string is a string containing valid Python code. If this code spans multiple lines, the lines must be terminated by a single newline ('\n') and not platform-specific variants (for example, '\r\n' on Windows). filename is a string containing the name of the file in which the string was defined (if any). kind is 'exec' for a sequence of statements, 'eval' for a single expression, or 'single' for a single executable statement. The resulting code object that is returned can be directly passed to exec() or eval() in place of a string.

complex([real [, imag]])

Type representing a complex number with real and imaginary components, real and imag, which can be supplied as any numeric type. If imag is omitted, the imaginary component is set to zero. If real is passed as a string, the string is parsed and converted to a complex number. In this case, imag should be omitted. If real is any other kind of object, the value of real.__complex__() is returned. If no arguments are given, 0j is returned.

Table 10.3 shows methods and attributes of complex.

Click here to view code image

delattr(object, attr)

Deletes an attribute of an object. attr is a string. Same as del object.attr.

Click here to view code image

dict([m]) or dict(key1=value1, key2=value2, ...)

Type representing a dictionary. If no argument is given, an empty dictionary is returned. If m is a mapping object (such as another dictionary), a new dictionary having the same keys and same values as m is returned. For example, if m is a dictionary, dict(m) makes a shallow copy of it. If m is not a mapping, it must support iteration in which a sequence of (key, value) pairs is produced. These pairs are used to populate the dictionary. dict() can also be called with keyword arguments. for example, dict(foo=3, bar=7) creates the dictionary {'foo': 3, 'bar': 7 }.

Table 10.4 shows operations supported by dictionaries.

dir([object])

Returns a sorted list of attribute names. If object is a module, it contains the list of symbols defined in that module. If object is a type or class object, it returns a list of attribute names. The names are typically obtained from the object’s __dict__ attribute if defined, but other sources may be used. If no argument is given, the names in the current local symbol table are returned. It should be noted that this function is primarily used for informational purposes (for example, used interactively at the command line). It should not be used for formal program analysis because the information obtained may be incomplete. Also, user-defined classes can define a special method __dir__() that alters the result of this function.

divmod(a, b)

Returns the quotient and remainder of long division as a tuple. For integers, the value (a // b, a % b) is returned. For floats, (math.floor(a / b), a % b) is returned. This function may not be called with complex numbers.

Click here to view code image

enumerate(iter, start=0)

Given an iterable object, iter, returns a new iterator (of type enumerate) that produces tuples containing a count and the value produced from iter. For example, if iter produces a, b, c, then enumerate(iter) produces (0,a), (1,b), (2,c). The optional start changes the initial value of the count.

Click here to view code image

eval(expr [, globals [, locals]])

Evaluates an expression. expr is a string or a code object created by compile(). globals and locals are mapping objects that define the global and local namespaces, respectively, for the operation. If omitted, the expression is evaluated using the values of globals() and locals() as executed in the caller’s environment. It is most common for globals and locals to be specified as dictionaries, but advanced applications can supply custom mapping objects.

Click here to view code image

exec(code [, global [, locals]])

Executes Python statements. code is a string, bytes, or a code object created by compile(). globals and locals define the global and local namespaces, respectively, for the operation. If omitted, the code is executed using the values of globals() and locals() as executed in the caller’s environment.

Click here to view code image

filter(function, iterable)

Creates an iterator that returns the items in iterable for which function(item) evaluates as True.

float([x])

Type representing a floating-point number. If x is a number, it is converted to a float. If x is a string, it is parsed into a float. For all other objects, x.__float__() is invoked. If no argument is supplied, 0.0 is returned.

Table 10.5 shows methods and attributes of floats.

format(value [, format_spec])

Converts value to a formatted string according to the format specification string in format_spec. This operation invokes value.__format__(), which is free to interpret the format specification as it sees fit. For simple types of data, the format specifier typically includes an alignment character of '<', '>', or '^', a number (which indicates the field width), and a character code of 'd', 'f', or 's' for integer, floating point, or string values, respectively. For example, a format specification of 'd' formats an integer, a specification of '8d' right-aligns an integer in an 8-character field, and '<8d' left-aligns an integer in an 8-character field. More details on format() and format specifiers can be found in Chapter 9.

frozenset([items])

Type representing an immutable set object populated with values taken from items which must be an iterable. The values must also be immutable. If no argument is given, an empty set is returned. A frozenset supports all of the operations found on sets except for any operations that mutate a set in-place.

getattr(object, name [,default])

Returns the value of a named attribute of an object. name is a string containing the attribute name. default is an optional value to return if no such attribute exists; otherwise, AttributeError is raised. Same as accessing object.name.

globals()

Returns the dictionary of the current module that represents the global namespace. When called inside another function or method, it returns the global namespace of the module in which the function or method was defined.

hasattr(object, name)

Returns True if name is the name of an attribute of object. name is a string.

hash(object)

Returns an integer hash value for an object (if possible). The hash value is primarily used in the implementation of dictionaries, sets, and other mapping objects. The hash value is always the same for any objects that compare as equal. Mutable objects usually don’t define a hash value, although user-defined classes can define a method __hash__() to support this operation.

hex(x)

Creates a hexadecimal string from an integer x.

id(object)

Returns the unique integer identity of object. You should not interpret the return value in any way (for example, it’s not a memory location).

input([prompt])

Prints a prompt to standard output and reads a single line of input from standard input. The returned line is not modified in any way. It does not include a line ending (e.g., '\n').

int(x [,base])

Type representing an integer. If x is a number, it is converted to an integer by truncating towards 0. If it is a string, it is parsed into an integer value. base optionally specifies a base when converting from a string.

In addition to their support for common math operations, integers also have a number of attributes and methods listed in Table 10.6.

isinstance(object, classobj)

Returns True if object is an instance of classobj or a subclass of classobj. The classobj parameter can also be a tuple of possible types or classes. For example, isinstance(s, (list, tuple)) returns True if s is a tuple or a list.

issubclass(class1, class2)

Returns True if class1 is a subclass of (derived from) class2. class2 can also be a tuple of possible classes, in which case each class will be checked. Note that issubclass(A, A) is True.

iter(object [,sentinel])

Returns an iterator for producing items in object. If the sentinel parameter is omitted, the object must either provide the method __iter__(), which creates an iterator, or the object must implement __getitem__(), which accepts integer arguments starting at 0. If sentinel is specified, object is interpreted differently. Instead, object should be a callable object that takes no parameters. The returned iterator object will call this function repeatedly until the returned value is equal to sentinel, at which point iteration will stop. A TypeError will be generated if object does not support iteration.

len(s)

Returns the number of items contained in s which should be some kind of container such as a list, tuple, string, set, or dictionary.

list([items])

Type representing a list. items may be any iterable object, the values of which are used to populate the list. If items is already a list, a shallow copy is made. If no argument is given, an empty list is returned.

Table 10.7 shows operations defined on lists.

locals()

Returns a dictionary corresponding to the local namespace of the caller. This dictionary should only be used to inspect the execution environment—changes made to the dictionary don’t have any effect on the corresponding local variables.

map(function, items, ...)

Creates an iterator that produces the results of applying function to the items in items. If multiple input sequences are supplied, function is assumed to take that many arguments, with each argument taken from a different sequence. In this case, the result is only as long as the shortest input sequence.

Click here to view code image

max(s [, args, ...], *, default=obj, key=func)

For a single argument, s, this function returns the maximum value of the items in s, which may be any iterable object. For multiple arguments, it returns the largest of the arguments. If the keyword-only argument default is given, it supplies the value to return if s is empty. If the keyword-only argument key is given, then the value v for which key(v) returns the maximum value is returned.

Click here to view code image

min(s [, args, ...], *, default=obj, key=func)

The same as max(s) except that the minimum value is returned.

next(s [, default])

Returns the next item from the iterator s. If the iterator has no more items, a StopIteration exception is raised unless a value is supplied to the default argument. In that case, default is returned instead.

object()

The base class for all objects in Python. You can call it to create an instance, but the result isn’t especially interesting.

oct(x)

Converts an integer, x, to an octal string.

Click here to view code image

open(filename [, mode [, bufsize [, encoding [, errors [, newline [, closefd]]]]]])

Opens the file filename and returns a file object. The arguments are described in detail in Chapter 9.

ord(c)

Returns the integer ordinal value of a single character, c. This value usually corresponds to the character’s Unicode code-point value.

pow(x, y [, z])

Returns x ** y. If z is supplied, this function returns (x ** y) % z. If all three arguments are given, they must be integers and y must be non-negative.

Click here to view code image

print(value, ... , *, sep=separator, end=ending, file=outfile)

Print a collection of values. As input, you can supply any number of values, all of which are printed on the same line. The sep keyword argument is used to specify a different separator character (a space by default). The end keyword argument specifies a different line ending ('\n' by default). The file keyword argument redirects the output to a file object.

Click here to view code image

property([fget [,fset [,fdel [,doc]]]])

Creates a property attribute for classes. fget is a function that returns the attribute value, fset sets the attribute value, and fdel deletes an attribute. doc provides a documentation string. Properties are often specified as a decorator:

Click here to view code image

class SomeClass:
    x = property(doc='This is property x')
    @x.getter
    def x(self):
        print('getting x')

    @x.setter
    def x(self, value):
        print('setting x to', value)

    @x.deleter
    def x(self):
        print('deleting x')

Click here to view code image

range([start,] stop [, step])

Creates a range object that represents a range of integer values from start to stop. step indicates a stride and is set to 1 if omitted. If start is omitted (when range() is called with one argument), it defaults to 0. A negative step creates a list of numbers in descending order.

repr(object)

Returns a string representation of object. In most cases, the returned string is an expression that can be passed to eval() to recreate the object.

reversed(s)

Creates a reverse iterator for sequence s. This function only works if s defines the __reversed__() method or it implements the sequence methods __len__() and __getitem__(). It does not work with generators.

round(x [, n])

Rounds the result of rounding the floating-point number x to the closest multiple of 10 to the power minus n. If n is omitted, it defaults to 0. If two multiples are equally close, it rounds towards 0 if the previous digit is even and away from 0 otherwise (for example, 0.5 is rounded to 0.0 and 1.5 is rounded to 2).

set([items])

Creates a set populated with items taken from the iterable object items. The items must be immutable. If items contains other sets, those sets must be of type frozenset. If items is omitted, an empty set is returned.

Table 10.8 shows operations on sets.

Click here to view code image

setattr(object, name, value)

Sets an attribute of an object. name is a string. Same as object.name = value.

Click here to view code image

slice([start,] stop [, step])

Returns a slice object representing integers in the specified range. Slice objects are also generated by the extended slice syntax a[i:i:k].

Click here to view code image

sorted(iterable, *, key=keyfunc, reverse=reverseflag)

Creates a sorted list from items in iterable. The keyword argument key is a single-argument function that transforms values before they are compared. The keyword argument reverse is a Boolean flag that specifies whether or not the resulting list is sorted in reverse order. The key and reverse arguments must be specified using keywords—for example, sorted(a, key=get_name).

staticmethod(func)

Creates a static method for use in classes. This function is usually used as a @staticmethod decorator.

str([object])

Type representing a string. If object is supplied, a string representation of its value is created by calling its __str__() method. This is the same string that you see when you print the object. If no argument is given, an empty string is created.

Table 10.9 shows methods defined on strings.

sum(items [,initial])

Computes the sum of a sequence of items taken from the iterable object items. initial provides the starting value and defaults to 0. This function usually only works with numbers.

super()

Returns an object that represents the collective superclasses of the class in which its used. The primary purpose of this object is to invoke methods in base classes. Here’s an example:

Click here to view code image

class B(A):
     def foo(self):
         super().foo()     # Invoke foo() defined by superclasses.

tuple([items])

Type representing a tuple. If supplied, items is an iterable object that is used to populate the tuple. However, if items is already a tuple, it’s returned unmodified. If no argument is given, an empty tuple is returned.

Table 10.10 shows methods defined on tuples.

type(object)

The base class of all types in Python. When called as a function, returns the type of object. This type is the same as the object’s class. For common types such as integers, floats, and lists, the type will refer to one of the other built-in classes such as int, float, list, and so forth. For user-defined objects, the type is the associated class. For objects related to Python’s internals, you will typically get a reference to one of the classes defined in the types module.

vars([object])

Returns the symbol table of object (usually found in its __dict__ attribute). If no argument is given, a dictionary corresponding to the local namespace is returned. The dictionary returned by this function should be assumed to be read-only. It’s not safe to modify its contents.

zip([s1 [, s2 [, ... ]]])

Creates an iterator that produces tuples containing one item each from s1, s2, and so on. The nth tuple is (s1[n], s2[n], ... ). The resulting iterator stops when the shortest input is exhausted. If no arguments are given, the iterator produces no values.

10.2 Built-in Exceptions

This section describes the built-in exceptions used to report different kinds of errors.

BaseException

Exception

ArithmeticError

LookupError

EnvironmentError

try:
    # Some operation
    ...
except ArithmeticError as e:
    # Math error

e.args

e.__cause__

e.__context__

e.__traceback__

AssertionError

AttributeError

BufferError

EOFError

FloatingPointError

GeneratorExit

IOError

ImportError

IndentationError

IndexError

KeyError

KeyboardInterrupt

MemoryError

ModuleNotFoundError

NameError

NotImplementedError

OSError

OverflowError

RecursionError

ReferenceError

RuntimeError

StopIteration

StopAsyncIteration

SyntaxError

SystemError

SystemExit

TabError

TypeError

UnboundLocalError

UnicodeError

ValueError

WindowsError

ZeroDivisionError

10.3 Standard Library

Python comes with a sizable standard library. Many of these modules have been previously described in the book. Reference material can be found at https://docs.python.org/library. That material is not repeated here.

The modules listed below are notable because they are generally useful for a wide variety of applications and for Python programming in general.

10.4 Final Words: Use the Built-Ins

In the modern world where there are hundreds of thousands of Python packages, it is easy for programmers to seek solutions to small problems in the form of third-party package dependencies. However, Python has long had an extremely useful set of built-in functions and datatypes. Combined with modules from the standard library, a wide range of common programming problems can often be solved using nothing beyond what Python already provides. Given a choice, prefer that.