# 4.2. Built-In Functions¶

Python provides a number of important built-in functions that we can use without needing to provide the function definition. The creators of Python wrote a set of functions to solve common problems and included them in Python for us to use. We’ve seen and used several already:

print()
len()
input()
int()
float()
str()
range()
min()
max()
sum()


You already have a good idea of what these do, but now we can describe them more precisely. For example: “The print() function prints its arguments on the screen, separating them with spaces if there are multiple arguments.” We now have the word arguments to describe the values we’ve been passing into the print() function.

Another example where we can describe a familiar function in terms of its return value and argument: “The len() function returns the number of items in its argument.”

Note

You should treat the names of built-in functions as reserved words (i.e., avoid using “max” as a variable name).

Technically, Python will allow you to “override” their built-in definitions, but this will likely to lead to confusion.

## 4.2.1. Math Functions¶

Python has a math module (sometimes called a library) that provides many familiar mathematical functions. Before we can use the module, we have to import it with an import statement:

import math


Note

Import statements are almost always written at the top of our program, above any other code. This gives us one quick place to look to see what modules the code is using, instead of having to look for import statments throughout the whole program.

This statement creates a module object named math that contains a large set of built-in mathematical functions (and some variables). To access one of the functions, you have to specify the name of the module and the name of the function, separated by a dot (also known as a period). This format is called dot notation.

Syntax pattern

Dot notation is used to access a function inside a module object:

<module name>.<function name>(<arguments>)


This can be read as “access <function name> inside <module name>, and call it with <arguments>.”

To access a variable within a module:

<module name>.<variable name>


In general, if we write A.B for any A and B, it means “the thing named B inside the module named A.”

Make sure you get the direction right! It is always accessing the name on the right in the module on the left.

This example uses a function named log10() inside the math module to compute the logarithm base 10 of a signal-to-noise ratio. The math module also provides a function called log() that computes logarithms base $$e$$. (If none of this is familiar to you, don’t worry! It’s just an example of some mathematical functions that are commonly used in certain types of calculations.)

This second example finds the sine of radians. The name of the variable is a hint that sin() and the other trigonometric functions (cos(), tan(), etc.) take arguments in radians. To convert from degrees to radians, divide by 360 and multiply by $$2 \pi$$. The constant $$\pi$$ is an important, commonly used value, and so it is provided in the math module as well:

The expression math.pi gets the variable pi from the math module. The value of this variable is an approximation of $$\pi$$, accurate to about 15 digits.

Rules of trigonometry can show that we can check the previous result by comparing it to the square root of two divided by two. The square root function is another common function provided by the math module:

The full list of functions and values defined in the math module is available in the official documentation for Python: Documentation for the math module

## 4.2.2. Random Numbers¶

Given the same inputs, most computer programs generate the same outputs every time, so they are said to be deterministic. Determinism is usually a good thing, since we expect the same calculation to yield the same result. For some applications, though, we want the computer to be unpredictable. Games are an obvious example, but there are more.

Making a program truly nondeterministic turns out to be not so easy, but there are ways to make it at least seem nondeterministic. One of them is to use algorithms that generate pseudorandom numbers. Pseudorandom numbers are not truly random because they are generated by a deterministic computation, but just by looking at the numbers it is all but impossible to distinguish them from random.

The random module provides functions that generate pseudorandom numbers (which we will simply call “random” from here on). Again, to use it, we just have to write import random at the top of our code.

The function random() returns a random float between 0.0 and 1.0 (including 0.0 but not 1.0). Each time you call random(), you get the next number in a long series. To see a sample, run this loop:

This program produces the following list of 10 random numbers between 0.0 and up to but not including 1.0. Every time you run it, it produces a different set of numbers.

The random() function is only one of many functions in the random module. The function randint() takes two arguments, a low value and a high value (in that order), and it returns an integer from the range between the two values (including both).

To choose an element from a sequence at random, you can use choice():

The random module also provides functions to generate random values from continuous distributions including Gaussian, exponential, gamma, and a few more. As with the math module, the random module is fully documented in Python’s official documentation: Documentation for the random module

## 4.2.3. Other Modules¶

The math and random modules are commonly used, especially when dealing with data. Many others are provided as part of what is called Python’s “Standard Library.” The full list is in Python’s documentation: The Python Standard Library. Scroll through that page to get a sense of what sorts of modules are available. You’ll see modules related to strings, files, numbers, dates, and much more.

Many common calculations and tools have been written and provided in modules. It is commonly said in programming: “Don’t reinvent the wheel.” Common, basic problems have been solved for you already and functions provided for them. If you use those functions, you can focus your time and energy on the more interesting problems that are more specific to your work.

Remember

To use any function provided by a module in Python’s standard library:

1. Write an import statement at the top of your program: import modulename

2. Use dot-notation to access a function within the module: modulename.functionname()