Python Standard Library Essentials

os talks to the operating system; sys talks to the Python interpreter itself.

import os, sys
print(os.getenv("HARVEST_SEASON", "autumn"))  # an environment variable, with a default
print(os.cpu_count())                          # CPU cores on this machine
print(sys.version_info[:2])                    # e.g. (3, 13)
print(sys.argv)                                # command-line arguments
print(sys.platform)                            # 'linux', 'win32', 'darwin'

Useful pieces of os: os.environ and os.getenv() for environment variables, os.getcwd() for the current folder, and os.replace() for atomic file renames. Useful pieces of sys: sys.argv for command-line arguments, sys.exit(code) to stop with an exit status, sys.stdin/sys.stdout/sys.stderr for streams, and sys.path for where imports are searched.

Keep the two concerns apart: settings for this run (arguments, environment variables) versus facts about the machine or interpreter (platform, version). Environment handling is covered in detail in environment variables and configuration.

pathlib.Path represents file-system paths as objects and replaces most of the older os.path functions:

from pathlib import Path
data = Path("harvest") / "2026" / "yields.csv"
print(data.name, data.suffix, data.parent)     # yields.csv .csv harvest/2026
print(Path.home(), Path.cwd())

A relative path such as Path("harvest") is resolved against the current working directory, the folder the program was started from, which isn't necessarily the folder containing your script. For files that sit next to your code, build paths from the script's location: Path(__file__).parent / "harvest". The directory operations lesson covers creating, listing and deleting with pathlib.

The collections module adds containers for common patterns:

from collections import Counter, defaultdict, deque, namedtuple

picks = ["pear", "apple", "pear", "plum", "pear"]
counts = Counter(picks)
print(counts.most_common(2))            # [('pear', 3), ('apple', 1)]

by_row = defaultdict(list)
by_row["north"].append("pear")          # no KeyError: starts with []
print(dict(by_row))

recent = deque(maxlen=3)
for weight in [12, 15, 9, 14]:
    recent.append(weight)
print(recent)                           # deque([15, 9, 14], maxlen=3)

Tree = namedtuple("Tree", "row variety")
print(Tree("north", "pear").variety)

• Counter counts hashable items and supports most_common(), + and -.
• defaultdict(factory) creates a default value for a missing key on first access. Just reading d[key] inserts that default, so use key in d to test membership without side effects.
• deque adds and removes at both ends quickly; with maxlen it keeps only the latest items.
• namedtuple creates lightweight tuples with named fields; dataclasses are the more flexible modern alternative.

The statistics module calculates common summaries without NumPy:

import statistics as st
weights = [12, 15, 9, 14, 15]
print(st.mean(weights), st.median(weights), st.mode(weights))   # 13 14 15
print(round(st.stdev(weights), 2), round(st.pstdev(weights), 2))  # 2.55 2.28

stdev() is the sample standard deviation (dividing by n − 1), appropriate when your data is a sample from a larger population. pstdev() is the population standard deviation (dividing by n), for when you have every value. Mixing them up gives slightly different numbers, which matters in reports.

The module also offers quantiles(), variance(), correlation() and linear_regression() (Python 3.10+). For large datasets or many columns, NumPy and pandas are faster; for a few hundred values in a script, statistics is perfectly adequate and needs no installation.

Two more modules repay early study because they replace whole loops:

from itertools import groupby, combinations, islice, chain
from functools import reduce, lru_cache

rows = ["north", "north", "south"]
print([(k, len(list(g))) for k, g in groupby(rows)])   # [('north', 2), ('south', 1)]
print(list(combinations(["pear", "plum", "fig"], 2)))  # every pair
print(list(chain([1, 2], [3])), list(islice(range(100), 3)))   # [1, 2, 3] [0, 1, 2]

• groupby groups consecutive equal items, so sort by the same key first.
• combinations, permutations and product generate arrangements without nested loops.
• islice takes part of any iterator, including endless ones.
• functools.lru_cache remembers function results, and functools.partial fixes some arguments of a function in advance.

These tools return lazy iterators, so wrap them in list() when you need to see or reuse the results.

Task: build a harvest summary using a path, a variety counter, a numeric statistic and a process setting.

import os
from collections import Counter
from pathlib import Path
from statistics import median

varieties = ["pear", "apple", "pear", "plum"]
weights = [12, 9, 15, 7]
out_dir = Path(os.getenv("REPORT_DIR", "reports"))

print("Most common:", Counter(varieties).most_common(1)[0][0])
print("Median weight:", median(weights))
print("Output folder:", out_dir)

This prints Most common: pear, Median weight: 10.5 and Output folder: reports when REPORT_DIR isn't set. For the worked check, the standard library type that counts repeated values is Counter.

The Python Standard Library documentation indexes every module, with dedicated pages for collections and statistics. Continue with environment configuration and pip and virtual environments. Practise with the Python exercises and Python quiz.