What a Library Is

A library is a collection of procedures that other programmers have already written, tested, and packaged so you can reuse them. Instead of writing your own square-root routine from scratch, you reach into a library and call the procedure that is already there. A library is a form of procedural abstraction: it lets you use powerful operations by name without knowing, or caring, how they are built internally.

In Python you bring a library into your program with import, then call its procedures with the library name, a dot, and the procedure name. The example below imports the math library and calls its sqrt procedure.

import math

x = 16
print(math.sqrt(x))

x <- 16
result <- squareRoot(x)
DISPLAY(result)

Notice what you did not have to do: you never wrote the algorithm that computes a square root. You only had to know the procedure's name and what it expects. That is the whole point of a library. On the right, AP pseudocode has no import keyword, but the idea is identical: a library provides a procedure like squareRoot that you simply call.

import math
print(math.floor(6.99))

An API Is the Instructions

An API, short for application program interface, is the description of how to use a library: the names of its procedures, what arguments each one takes, and what each one returns. The API is the contract between you and the library. You read the API, sometimes called the documentation, to learn how to call a procedure correctly, exactly the way you read the instructions on a microwave without knowing the electronics inside.

Because the API hides the internal details, two things follow. First, you must supply the right arguments in the right order, because that is what the documentation promises. Second, you can predict a procedure's result from its documented behavior alone. The math library documents that floor rounds down and ceil rounds up:

import math

# floor: largest integer not greater than x
print(math.floor(7.9))
# ceil: smallest integer not less than x
print(math.ceil(7.1))

DISPLAY(floor(7.9))
DISPLAY(ceil(7.1))

Reading that documentation tells you floor(7.9) is 7 and ceil(7.1) is 8, even though you never see the code that computes them. That is what an exam question means when it hands you a described procedure and asks for the result.

print(math.sqrt(81))

Use It, or Rebuild It Yourself

Why does a library matter? Because reusing existing, well-tested code saves development time and reduces errors. Someone already debugged the square-root procedure across millions of inputs. If you rewrote it yourself you would spend hours and probably introduce a bug the library long ago fixed. Choosing to call a library procedure instead of reimplementing it is one of the most practical decisions a programmer makes.

You can also build your own small library: a set of procedures you write once and then call by name throughout a program. That is exactly what procedural abstraction gives you, and it is why a library and a procedure are the same idea at different scales. Here is a two-procedure mini library and a call to it:

# a tiny library of procedures
def area(w, h):
    return w * h

print(area(4, 3))

PROCEDURE area(w, h)
{
    RETURN(w * h)
}

DISPLAY(area(4, 3))

Once area exists, the rest of the program just calls area(4, 3) and trusts it to return 12. The caller does not re-derive width times height every time. That reuse is the benefit, whether the procedure came from Python's math library or from a library you wrote yourself.

import math
print(math.ceil(4.1))

Predicting a Result From Documentation

Most library questions on the exam are not about writing code at all. They give you a procedure's documented behavior and one or two calls, then ask what is displayed. Use a short, mechanical routine:

1. Read the documentation sentence and restate the rule in your own words.
2. Identify each argument in the call and match it to the documented parameter.
3. Apply the rule to those exact argument values.
4. Do not assume any behavior the documentation did not promise.

For instance, a library documents clamp(v, lo, hi) as: returns v when it lies between lo and hi, returns lo when v is smaller, and returns hi when v is larger. Then clamp(12, 0, 10) must return 10, because 12 is larger than the high bound. You solved that with the documentation alone, never seeing inside clamp. That is exactly the skill AAP-3.D is testing.

Key Vocabulary