This series of posts is for those who have used a programming language before but are not familiar with Python. This post concludes — at least for now — this series.

We’ll wrap things up with an overview of Python’s many built-in functions.

The Built-in Functions page of the Python documentation currently lists 71 functions. (Python’s documentation is very good. And because Python is a well-known language, queries about it to your favorite Ai can also be useful.)

The built-in data types (aka classes) all behave like functions (they are callable), so they are considered among Python’s built-in functions:

We explored this in part 1, part 2, and part 3, so see those parts for details. The examples above all return default objects because no parameters were provided.

When provided with parameters these functions convert one data type to another:

I haven’t mentioned the complex number data type (line #7 in both the above). Python includes complex numbers among its built-in data types. The example directly above creates the complex number i.

Note that when turning a string into bytes or a bytearray (lines #11 and #12), the encoding parameter is required. Note also that the object constructor takes no parameters and always returns a basic object.

The slice function creates an object for indexing objects that behave as lists:

Note that slice requires at least one parameter (just as indexing does) and takes up to three (start, stop, step, again, just as indexing does).

When run, this prints:

a_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
a_string = 'Hello, World!'
a_slice = slice(2, 6, None)

list_part = [2, 3, 4, 5]
list_part = [2, 3, 4, 5]

string_part = 'llo,'
string_part = 'llo,'

The range function returns an ordered list of (unique) numbers. A simple example is that range(5) returns 0,1,2,3,4. A more involved example is range(10,40,5), which returns 10,15,20,25,30,35. The enumerate function binds index numbers to a list of items.

Both functions frequently appear in for loops:

Note both are among the functions that return a list-like object rather than an actual list. (They return iterator or generator objects.) To get actual list objects, we use the list constructor.

[This may seem inconvenient, but it comes in handy when dealing with very large lists. Iterators and generators don’t create copies of their list; they maintain a reference to the “current” item. Therefore, they don’t consume much memory.]

When run, this prints:

a_range = range(0, 5)

list_of_range = [0, 1, 2, 3, 4]

ix = 0
ix = 1
ix = 2

an_enumeration = <enumerate object at 0x0000022628D6E480>

list_of_pairs = [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]

list_of_enumeration = [(0, 'A'), (1, 'B'), (2, 'C'), (3, 'D')]

0: foo
1: bar
2: nop
3: gif

A number of other built-in functions return list-like objects. Five commonly used ones are: reversed, sorted, zip, filter, and map:

It should be obvious what the reversed and sorted functions do.

The zip function combines multiple list-like objects into a single list of tuples where each tuple has one element from each list. Note that zip stops when any of its input lists ends. It won’t go beyond its shortest input list.

The filter function takes two parameters: a function and a list-like object. It uses the function to filter the list, passing each list item in turn to the filter function. If that function returns True, the item is retained, else it’s discarded.

The map function also takes a function and a list-like object, but it returns a same-sized list consisting of the returned values from the mapping function. In this case, the squares of the numbers in the input list.

When run, this prints:

a_list = [1, 2, 3, 4, 5, 6, 7, 8]
a_string = 'Hello!'

reversed_list = [8, 7, 6, 5, 4, 3, 2, 1]
reversed_string = ['!', 'o', 'l', 'l', 'e', 'H']

sorted_list = [1, 2, 3, 4, 5, 6, 7, 8]
sorted_string = ['!', 'H', 'e', 'l', 'l', 'o']

1 - H
2 - e
3 - l
4 - l
5 - o
6 - !

items = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

filtered_items = [0, 1, 2, 3, 4]

mapped_items = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121]

The len (length), max (maximum), min (minimum), sum, all, and any functions expect a list-like object, but these return a numerical value:

The len function returns the length of any list.

The max function and the min function return, respectively, the maximum and minimum of any list comprised of sortable items (i.e. that can be compared with less-than). That means we can, for example, find the alphabetic minimum or maximum in a list of strings.

The sum function expects a list of numeric objects it can sum together (integers, floats, complex numbers, or any data type that can be added with each other or other numeric values).

[Recall how the Point class we created in part 8, part 9, and part 10 implemented methods to do math with Point objects, so we can use the sum function with a list of Point objects. But while we did implement methods for comparing two Point objects for equality (i.e. using the == and != operators), we did not implement the methods that allow greater-than or less-then comparisons (using the < or <= or >= or > operators), so we cannot use the min or max functions with Point objects.]

The all function and the any function both take a list of items and return a value based on their Boolean values. They determine whether all items are True or any item is True, respectively.

When run, this prints:

len(a_list) = 7

max(a_list) = 105
min(a_list) = 21
sum(a_list) = 500

all([21, 42, 63, 84]) = True
all([21, 42, 0, 84]) = False

any([21, 42, 63, 84]) = True
any([0, 0, 63, 0]) = True
any([0, 0, 0, 0]) = False

There are four useful math functions: abs, divmod, pow, and round:

The abs function returns the absolute value of a numeric input.

The divmod function performs an integer division, dividing the first argument by the second, and then performs a modulus operation using the same arguments. It returns both results in a tuple. Lines #16 and #17 show one form of the equivalent operation. Lines #21 and #22 show an alternate form using the integer division operator (//).

The pow function is equivalent to using the power operator (**). Note that both can handle negative exponents as well as fractional ones [see Exponents on my other blog for more on negative and fractional powers].

The round function rounds floating point numbers to the desired number of decimal digits (or none if the ndigits parameter isn’t supplied).

When run, this prints:

abs(-42) = 42
abs(-42.21) = 42.21

row=6, col=7
row=6, col=7
row=6, col=7

4 to the power of 2 = 16
4 to the power of -2 = 0.0625
4 to the power of 2.7 = 42.22425314473263

4**2 = 16
4**-2 = 0.0625
4**2.7 = 42.22425314473263

round(2.71828) = 3
round(3.14159) = 3
round(2.71828, 3) = 2.718
round(3.14159, 3) = 3.142

The bin, hex, and oct functions return the binary, hexadecimal, and octal string versions of their numeric inputs.

The chr function (character) converts a number to a character based on its Unicode ordinal value. The ord function (ordinal) does the opposite, returning the ordinal index value of a character:

Note that we can also use formatted strings to obtain the binary, hexadecimal, or octal strings of a numeric value (lines #4, #8, and #12), and these offer a bit more control over how the number is displayed. For one, the built-in functions prefix the number with 0b, 0x, or 0o whereas formatted output does not. These three are mainly useful in an interactive environment when we want to convert a number.

The chr and ord functions are far more useful and make frequent appearances in code that processes text. For instance, they enabled the ROT13 example from last time.

When run, this prints:

bin(42) = '0b101010'
42 is 00101010 in binary

hex(42) = '0x2a'
42 is 002a in hexadecimal

oct(42) = '0o52'
42 is 000052 in octal

chr(42) = '*'

ord("*") = 42

We been using the print function throughout this series. Here we’ll see some of its extended capabilities. We’ve also touched on the difference between a string version of an object and its representation string, which we get using the str and repr functions respectively. The ascii function is related to the repr function in that both return a representation string. The ascii function also converts any non-printable characters to backslash “escaped” versions. The format function is another way to format output strings:

The print function has a sep parameter (line #8) that controls the separator between multiple values (the default is “, “). And note that print can take multiple values. The end parameter (lines #12 and #13) controls what print puts at the end (the default is “\n”).

The file parameter (lines #21 to #23) lets us redirect output from stdout to a file. Note that we can only use print with text files, not binary files (opened with mode="w" but not with mode="wb"). [See part 11 for more on opening files.]

Lines #31 to #37 illustrate different ways to get an object’s print string or representation string. Note that the str function is a data type (aka class) used as a constructor but the repr function is just a function that returns a string.

The ascii function (line #42) returns a representation string that escapes embedded non-printable characters (in this case, the tab and newline). Both str and repr send the tab and newline to the output as is.

The format function (lines #46 to #48) takes a value (any object) and a formatting string appropriate for that value. If no format string is given, the default is an empty string, which returns the string value of the object.

When run, this prints:

21 42 Hello! [1, 2, 3]

21;42;63;86

This text is all on one line!

wrote: C:\Demo\HCC\Python\output.txt

Hello, World!
using str: Hello, World!
using repr: 'Hello, World!'

using debug: a_string = 'Hello, World!'
using debug !s: a_string = Hello, World!
using debug !r: a_string = 'Hello, World!'

a_string = 'Hello,\tWorld!\n'

format(42) = '42'
format(42, "") = '42'
format(42, "04x") = '002a'

Six built-in functions (type, super, id, hash, callable, isinstance, and issubclass) are for dealing with classes and instances of classes:

Lines #3 to #23 define a simple name/value class called base. In the dunder init method (lines #6 to #9) we create two instance properties: name and value. We set these with (required) values passed to the method.

Lines #11 to #13 implement the dunder hash method, which must return an integer value. Providing this method allows instances of the class to act as keys in dictionaries or items in a set. Note that when we implement dunder hash, we should also implement the dunder eq method to enable object comparisons with the equals operator (==). I skipped it here to save space.

Lines #15 to #19 implement the dunder call method, which lets us treat instances of this class as function objects.

Lines #21 to #23 implement the dunder repr method, which gives objects of this class a string representation (something we should always do).

Lines #25 to #42 implements an extension of base called derived. This class inherits everything from the base class and then either adds new properties (line #32) and methods or overrides existing ones from base.

Lines #28 to #32 re-implement the dunder init method, and this overrides the one from the base class. We use the built-in super function to give us a reference to the superclass (i.e. base) and use that to call the base class’s dunder init method (line #31).

Lines #34 to #38 re-implement the dunder call method, which overrides the one from the base class, and we again use the super function to invoke that class’s dunder call method.

Lines #40 to #42 re-implement the dunder repr method to account for the dtype property, and this completely replaces the dunder repr method from base.

Lines #45 to #51 create two new instances of the base class (b1 and b2) and two new instances of the derived class (d1 and d2). Lines #53 to #98 exercise these new instances using various built-in functions.

Lines #53 to #56 invoke the dunder repr method to obtain and print string representations. Lines #65 to #62 use the type function to obtain each instance object’s data type (aka class). Note that type returns the object’s actual class (not a string). Lines #65 to #68 use the id function to obtain each object’s ID (memory location). Lines #71 to #74 use the hash function to get each objects hash value (which invokes the object’s dunder hash method).

Lines #77 to #80 use the callable function to determine whether an object has a dunder call method. Note this doesn’t invoke that method, it only tells us the method exists and we can treat the object as a function.

Likewise, the isinstance function (lines #83 to #86 and #88 to #91) returns True or False depending on whether a given object is an instance of a given class. The issubclass function (lines #94 to #97) returns True or False depending on whether a given class is a subclass of some other given class.

When run, this prints:

b1 = Foo: 21
b2 = Bar: 42
d1 = Alex: 86.5 is <class 'float'>
d2 = Blair: Drew is <class 'str'>

type(b1) = <class '__main__.base'>
type(b2) = <class '__main__.base'>
type(d1) = <class '__main__.derived'>
type(d2) = <class '__main__.derived'>

id(b1) = 2799129471232
id(b2) = 2799129427024
id(d1) = 2799129471568
id(d2) = 2799129427344

hash(b1) = 8498221605137793095
hash(b2) = -6886228356769053774
hash(d1) = 7948385794103204923
hash(d2) = 1533453739743887147

callable(b1) = True
callable(b2) = True
callable(d1) = True
callable(d2) = True

isinstance(b1, base) = True
isinstance(b1, derived) = False
isinstance(b2, type(b1)) = True
isinstance(b2, type(d1)) = False

isinstance(d1, base) = True
isinstance(d1, derived) = True
isinstance(d2, type(b1)) = True
isinstance(d2, type(d1)) = True

issubclass(base, tuple) = False
issubclass(base, derived) = False
issubclass(derived, base) = True
issubclass(type(d1), type(b1)) = True

Four built-in functions let us probe and manipulate instance and class attributes. The hasattr function returns True or False depending on whether the object has the specified attribute. The getattr function returns the value of the specified attribute, and the setattr function changes the value of the specified attribute. Lastly, the delattr function deletes the specified attribute:

Note that the getattr function has an optional third parameter that provides a default value in case attribute doesn’t exist. If the parameter isn’t supplied and the attribute does not exist, Python raises an Exception.

Lines #52 to #58 demonstrate using getattr to obtain an instance object’s method, while lines #60 to #66 demonstrate using getattr to objection a class’s method. Note how, in the former case, the self parameter is pre-supplied, but in the latter case, an object must be provided. (This is because the object knows itself, but the class has no way to know which instance is involved.)

The setattr function has a required third parameter that provides the new value for the attribute. Note that, if the attribute doesn’t exist, setattr creates it.

When run, this prints:

point-1 str  = [2.1, 4.2, 6.3]
point-1 repr = <Point @022d1a332900>

hasattr(p1, "x") = True
hasattr(p1, "w") = False

hasattr(p1, "__str__") = True
hasattr(p1, "__repr__") = True
hasattr(p1, "__eq__") = True
hasattr(p1, "__hash__") = True
hasattr(p1, "foobar") = False

getattr(p1, "x") = 2.1
getattr(p1, "w", -1) = -1
OOPS! "'Point' object has no attribute 'w'" (AttributeError)

<bound method Point.__str__ of <Point @022d1a332900>>
object_str_method() = '[2.1, 4.2, 6.3]'

<function Point.__str__ at 0x0000022D1A411B20>
class_str_method(p1) = '[2.1, 4.2, 6.3]'

getattr(p1, "w") = 8.4
getattr(p1, "u") = 0.0

getattr(p1, "x", "Gone!") = 'Gone!'
getattr(p1, "y", "Gone!") = 'Gone!'
getattr(p1, "z", "Gone!") = 'Gone!'
getattr(p1, "w", "Gone!") = 8.4
getattr(p1, "u", "Gone!") = 0.0

We’ve seen the built-in iter and next functions before (see part 3, for instance), but here’s a quick demo:

When run, this prints:

<list_iterator object at 0x0000017A35F64100>

next(iter_list) = 1
next(iter_list) = 2
next(iter_list) = 3
next(iter_list) = 4
next(iter_list) = 5
next(iter_list) = 6
OOPS! Got a StopIteration

<str_ascii_iterator object at 0x0000017A33BA2BF0>

next(iter_string) = 'A'
next(iter_string) = 'B'
next(iter_string) = 'C'
next(iter_string) = 'D'
next(iter_string) = 'E'
next(iter_string) = 'F'
OOPS! Got a StopIteration

Note that when an iterator is exhausted, it cannot be reset. Iterators are once through and done. They are among the functions that return a list-like object that is not a list.

We’ve also seen the built-in property, classmethod, and staticmethod functions before (see part 10):

All three are decorator functions [see also Function definitions]. Decorators add a wrapper around a function or class and can modify the function or class they wrap. These are advanced topics we’ll cover in detail another time.

The property decorator (lines #11 and #14) converts a method to an attribute. In this 2D Point class, dunder init creates attributes called _x and _y (lines #8 and #9; the leading underbar is canonical Python for “this is a private attribute”). Instead, we use a property decorator to convert the x and y methods to (read-only) attributes. When dunder repr uses self.x and self.y, it is accessing the properties.

The classmethod decorator (lines #17 and #20) converts an instance method to a class method. Rather than a self parameter, class methods have a class parameter (which we spell cls because class is a reserved keyword). Class methods only know about the class, not any instance object. We use it here to create two methods that return pre-determined Point objects.

The staticmethod decorator (line #23) converts an instance method to a static classmethod. These have neither a self nor a cls parameter. They are essentially ordinary functions but including them in the class associates the function with the data type.

When run, this prints:

[+2.100, +4.200]
[+1.000, +0.000]
[+0.000, +1.000]

Point.dot_product(p1, px) = 2.1
Point.dot_product(p1, py) = 4.2

Two built-in functions, globals and locals, return a dictionary of available variables:

The globals function returns a dictionary of variables at the module level.

The locals function returns a dictionary of variable at the current scope (which means it returns the same names as globals when called at the module level.

When run, this prints:

Globals:
__name__: __main__
__doc__: None
__package__: None
__loader__: <class '_frozen_importlib.BuiltinImporter'>
__spec__: None
__annotations__: {}
__builtins__: <module 'builtins' (built-in)>
__file__: C:\Demo\HCC\Python\source\fragment.py
Red: #ff0000
Green: #00ff00
Blue: #0000ff
my_function: <function my_function at 0x0000024AEC291940>

Locals:
r: #ff0000
g: #00ff00
b: #0000ff
x: 21
y: 42
name: my_function
value: <function my_function at 0x0000024AEC291940>

The first list, from globals, contains many special dunder names (names enclosed in double underbars). For example, the __name__ entry holds the name of the current module (in this case __main__ — see part 7 for details), and __file__ contains the filename.

The second list, from locals, contains only the local variables from my_function.  These include the function parameters as well as the name and value variables used in the for loops.

Three built-in functions, vars, dir, and help, explore Python objects and are mainly intended for the interactive development environment:

The vars function (line #13) returns a dictionary listing the variables of a given object. If invoked without an argument, it acts like locals.

The dir function (line #18) returns a list a given object’s variable names (but not values). If invoked without an argument, it is the equivalent of:

list(sorted(locals().keys()))

It returns a sorted list of variable names.

The help function (line #23) is an interactive utility that writes output to the console. The function doesn’t return a value (technically, it returns None). If invoked without an argument, it prints information about the help function. If invoked with an argument, it prints information about the passed object.

When run, this prints:

vars(Point):
__module__: __main__
__firstlineno__: 3
__doc__: Simple 3D point class.
__init__: <function Point.__init__ at 0x000002D0A49F1940>
__static_attributes__: ('x', 'y', 'z')
__dict__: <attribute '__dict__' of 'Point' objects>
__weakref__: <attribute '__weakref__' of 'Point' objects>

dir(Point):
__class__
__delattr__
__dict__
__dir__
__doc__
__eq__
__firstlineno__
__format__
__ge__
__getattribute__
__getstate__
__gt__
__hash__
__init__
__init_subclass__
__le__
__lt__
__module__
__ne__
__new__
__reduce__
__reduce_ex__
__repr__
__setattr__
__sizeof__
__static_attributes__
__str__
__subclasshook__
__weakref__

help(Point):
Help on class Point in module __main__:

class Point(builtins.object)
 |  Point(x=0, y=0, z=0)
 |
 |  Simple 3D point class.
 |
 |  Methods defined here:
 |
 |  __init__(self, x=0, y=0, z=0)
 |      New instance.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Sometimes the output of these functions is lengthy. The help function, in particular, prints very full documentation of whatever object is passed to it. The best thing is to actually try these in the Python IDLE [see part 7].

This post has gotten quite long but still hasn’t touched on all 71 built-in functions. One of the remaining ones, the open function for reading and writing files, was discussed at length in part 11.

The input function provides a way to get user input:

Here’s what it looked like when run:

Type some stuff, and press [Enter]:
This is a line of text.
Thank you.

You typed:
This is a line of text.

Is that correct? [Y]/[N] + [Enter]: y
Input validated.

The remaining functions are fairly specialized, and I’ll just mention them in passing:

• aiter — the asynchronous version of iter
• anext — the asynchronous version of next.
• breakpoint — halt execution and enter debugger at this point.
• compile — compile Python source code into an executable code object.
• eval — evaluate Python source code and return a value.
• exec — execute Python source code.
• memoryview — returns a “memory view” object of its given object.
• __import__ — an alternate way to import modules.

Chances are you won’t use most of these unless you become a Python developer and get deep into the Python weeds.

And on that note, we’re done for this first series. I hope it was helpful.

Link: Zip file containing all code fragments used in this post.

∅