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
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
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 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.
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
B, it means “the thing named
B inside the module named
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
This second example finds the sine of
radians. The name of the
variable is a hint that
sin() and the other trigonometric functions
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:
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
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.
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.
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.
random() function is only one of many functions in the
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
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¶
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.
To use any function provided by a module in Python’s standard library:
Write an import statement at the top of your program:
Use dot-notation to access a function within the module: