You Have Already Used Libraries

The word library can sound like a new category of programming, but you have already been using library code. When you wrote CSV files, you used csv. When the study log started recording dates, you used datetime. When the project moved toward structured data in Structuring Your Data, it used json.

Those tools are not part of the tiny core syntax of Python. They are code that comes with Python and can be imported when needed. They save you from writing low-level details yourself:

import csv

with open("sessions.csv", encoding="utf-8") as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

The for loop is Python syntax. The open function is a built-in. The csv.reader function comes from the csv module. A real program is usually a mixture of these layers.

import csv

reader = csv.reader(f)

Built-ins, Modules, Packages, Libraries

The vocabulary is a little fuzzy in everyday conversation, so use these definitions as working definitions rather than legal contracts.

A built-in is available without importing anything:

print(len(["math", "history"]))

A module is one Python file or module-like unit that you import by name:

import math

print(math.sqrt(49))

A package is a collection of modules arranged together. Third-party tools such as pandas and NumPy are packages in this sense, even though people often call them libraries.

A library is the broader idea: reusable code intended to be used by other programs. The Python standard library is the collection of modules and packages that come with Python. Third-party libraries are installed separately.

An API is the surface a library gives you to use it: the names you call, the arguments they expect, the values they return, and the behavior they promise.

Standard Library and Third-Party Libraries

Python comes with a large standard library. You install Python, and modules such as csv, json, math, random, and datetime are already available. You do not install them separately.

Third-party libraries are written and distributed separately from Python itself. They are installed into your local Python environment. In this part, the important third-party libraries are:

• NumPy, which is built around arrays of numbers and operations over whole arrays.
• pandas, which is built around table-shaped data.

The study log is a good reason to learn pandas. You already know how to compute totals, averages, per-subject summaries, date windows, and rankings with loops. Pandas gives you a table abstraction that expresses many of those operations more directly.

Libraries Do Not Replace Understanding

Libraries make powerful operations short. That is useful, but it can also hide decisions.

For example, this pandas expression will eventually make sense. You do not need to know the syntax yet; for now, read it as a preview of the kind of summary pandas can express:

df.groupby("subject")["minutes"].sum()

It means “group the rows by subject, take the minutes column in each group, and sum the minutes.” Summarizing Data with pandas will teach the groupby syntax carefully. The line is short because pandas already knows how to group rows and sum columns. But the programming idea is not new. In Summarizing Your Data, you wrote the same kind of summary yourself with loops.

That previous work matters. If the result looks wrong, you need to know what the result should mean. Did the grouping use the right column? Are minutes numbers or text? Are subjects consistently lowercase? Are future-dated sessions still present? Libraries give you better tools, not better judgment by default.

What the Library Does Not Decide

A library does not know what your program means by “recent”, “long”, “valid”, or “best”. Those are still design choices.

For example, pandas can group sessions by subject. It cannot decide whether "Math" and "math" should be treated as the same subject. It can calculate an average. It cannot decide whether an empty average should be printed as 0, None, or "No sessions yet." It can sort rows by minutes. It cannot decide whether ties should keep their original order or be broken by date.

That is why the course has spent so much time on edge cases and specifications. Here is the same pandas preview again. The library call is only one line inside a larger decision:

totals = df.groupby("subject")["minutes"].sum()

This line assumes that the pandas table, called a DataFrame later in this part, has the shape the code expects:

• the table has a column named subject,
• the table has a column named minutes,
• the minutes values are numbers,
• and the subject names are already normalized enough for grouping.

If any of those assumptions is false, the line may fail, or worse, it may produce a plausible but misleading result. Library use is therefore also assumption management.

A Library-Use Loop

When you meet a new library feature, use a small loop:

1. Import the library or name.
2. Try the smallest possible example.
3. Print or inspect the result.
4. Change one thing and run again.
5. Only then fit it into your real program.

For example:

from datetime import date

day = date.fromisoformat("2026-05-10")
print(day)
print(type(day))

This is deliberately tiny. It answers two questions: what value comes back, and what type is it? Those two questions are enough to prevent many library-use bugs.

from datetime import date

session_day = date.fromisoformat("2026-05-10")
print(session_day.year)

Check Your Understanding

1. What is the difference between Python syntax and a function from a module?
2. Why is csv available without installing anything, but pandas is not?
3. What does the API of a library include?
4. Why is it useful to know the loop-based version of a pandas summary before using the pandas version?