Modules, packages and environments

Make a day13 folder for today’s files and open it in your editor, as on earlier days. Some of today’s examples are small projects of two or more files; give each one its own folder inside day13 (for example day13/shop/), as the file titles show.

Day 12’s to-do manager was already long enough that finding a function took scrolling. Today you learn how Python programs are built from pieces: code that ships with Python, your own code split across files, and code other people have written, installed separately for each project.

On Day 2 you found a square root with 9 ** 0.5. That works, but it is not obvious to a reader, and many jobs (rounding up, the number π, dates, random numbers) have no operator at all. Python keeps tools like these in separate files and lets each program load only what it needs.

A module is a file of Python code (functions, variables, and so on) that other programs can use. Python comes with hundreds of modules already written and installed; together they are called the standard library. To use a module, a program imports it with the import statement:

import math

• import is a keyword. math is the module’s name: the file name without .py.
• Python finds the module, runs its code once, and makes a name, math, that refers to the whole module.
• You then reach anything inside the module with a dot: math.sqrt is “the sqrt function that lives in math”. This is the same dot you used on Day 3 for string methods such as name.upper(), read as “belongs to”.

Imports go at the top of the file, so a reader sees at once which modules the program depends on. The math module holds mathematical functions and constants:

>>> import math
>>> math.sqrt(16)
4.0
>>> math.sqrt(2)
1.4142135623730951
>>> math.pi
3.141592653589793
>>> math.floor(2.7)
2
>>> math.ceil(2.1)
3

• math.sqrt(16) is the square root, always a float.
• math.pi is a variable, not a function, so there are no parentheses. A variable stored in a module is often called a constant when it is meant never to change.
• math.floor(2.7) rounds down to the whole number below; math.ceil(2.1) rounds up to the whole number above. Both give an int.

import math

radius = 3
area = math.pi * radius ** 2
print(f"Area: {area:.2f}")
print(f"Side of a square with the same area: {math.sqrt(area):.2f}")

Area: 28.27
Side of a square with the same area: 5.32

Now vary the job. A wall of 23 square metres needs paint, and one can covers 10. You cannot buy 2.3 cans, so the program must round, but which way?

import math

wall_area = 23
area_per_can = 10
exact = wall_area / area_per_can
print(f"Exact: {exact}")
print(f"round(): {round(exact)} cans")
print(f"math.ceil(): {math.ceil(exact)} cans")

Exact: 2.3
round(): 2 cans
math.ceil(): 3 cans

The built-in round() from Day 2 goes to the nearest whole number, which is 2, and 2 cans leave 3 square metres unpainted. math.ceil always goes up, which is what “buy enough” means. Use ceil when a part-filled thing still counts as a whole one (cans, buses, pages), and floor when only complete ones count (full hours, whole boxes filled).

side = math.sqrt(49)
print(side)

Traceback (most recent call last):
  File ".../day13/forgot_import.py", line 1, in <module>
    side = math.sqrt(49)
           ^^^^
NameError: name 'math' is not defined. Did you forget to import 'math'?

import math

price = 7.6
print(math.floor(price), math.ceil(price))
print(math.sqrt(81) + 1)

7 8
10.0

Writing math. in front of every call is clear but can get long in a formula that uses sqrt five times. Python has a second form of import that brings chosen names straight into your file.

from math import pi, sqrt

• from names the module; import lists the names you want from it, separated by commas.
• Python still loads the whole module, but it creates only the names you listed, here pi and sqrt. It does not create the name math.
• You then use the names with no dot: sqrt(25).

from math import pi, sqrt

width = 3
height = 4
diagonal = sqrt(width ** 2 + height ** 2)
print(f"Diagonal: {diagonal}")
print(f"Half a turn is {pi:.4f} radians")

Diagonal: 5.0
Half a turn is 3.1416 radians

The two forms make different names:

import math keeps every call labelled with where it came from, which helps a reader. from math import sqrt is shorter, but a reader who sees sqrt on line 40 must scroll up to find out where it came from. Both are correct; most programmers use import module by default and from for a few names they use constantly.

There is also from math import *, where * means “every name in the module”. Avoid it. It hides where names came from, and it can silently replace names you already had. math has a constant called e (the number 2.718…), so:

e = "excellent"
print(e)
from math import *
print(e)

excellent
2.718281828459045

Line 3 created a new e that replaced yours, and nothing warned you. A program that later printed a grade would print a number instead.

from math import floor

minutes = 135
hours = math.floor(minutes / 60)
print(f"{hours} full hours")

NameError: name 'math' is not defined. Did you forget to import 'math'?

from math import floor

minutes = 135
hours = floor(minutes / 60)
print(f"{hours} full hours")

2 full hours

Some module names are long, and some clash with names you want to use yourself. Python lets you choose the name an import creates.

import module as other_name loads the module but calls it other_name in your file. The new name is an alias: a second name you pick for something. Here is the standard library’s statistics module, which has a name long enough to be tiring to type:

import statistics as stats

scores = [72, 88, 91, 65]
print(f"Mean: {stats.mean(scores)}")
print(f"Median: {stats.median(scores)}")

Mean: 79
Median: 80.0

as also works on a single name from a from import, which helps when the module’s name for something is not the word you would use:

from statistics import mean as average

temperatures = [18.5, 21.0, 19.0]
print(f"Average: {average(temperatures)}")

Average: 19.5

from statistics import mean as average creates only the name average; mean and statistics do not exist in this file. Some aliases are so common that every Python programmer knows them. You will meet ones like import numpy as np in other people’s code, where numpy is a package that you install yourself (13.10).

import statistics as stats

ages = [15, 16, 16, 17]
print(statistics.mean(ages))

NameError: name 'statistics' is not defined. Did you forget to import 'statistics'?

Here is the good news about modules: any .py file you write is already one. If you put some functions in pricing.py, another file in the same folder can write import pricing and use them exactly as it uses math. This is how you split a long program across files.

Why split at all? The Day 12 to-do manager mixed two jobs in one file: functions that change the task list, and the menu loop that talks to the user. Separating them gives:

• Shorter files, each about one thing, so you find code faster.
• Reuse: a second program (a web version of the to-do list, say) could import the same task functions.
• Safer changes: you can change the menu without touching code that already works.

"""Prices for the school shop: sales tax and money formatting."""

TAX_RATE = 0.08


def with_tax(price):
    """Return the price with sales tax added."""
    return price * (1 + TAX_RATE)


def format_price(amount):
    """Return an amount as dollars with two decimal places, like $4.32."""
    return f"${amount:.2f}"

import pricing

basket = {"notebook": 3.50, "pens": 2.25, "folder": 1.75}

total = 0
for item, price in basket.items():
    cost = pricing.with_tax(price)
    total += cost
    print(f"{item}: {pricing.format_price(cost)}")
print(f"Total: {pricing.format_price(total)}")
print(f"Tax rate: {pricing.TAX_RATE}")

notebook: $3.78
pens: $2.43
folder: $1.89
Total: $8.10
Tax rate: 0.08

To run it, the terminal must be inside the shop folder. Either open shop itself in your editor, or move the terminal there with the cd command (“change directory”), which works the same on macOS, Linux, and Windows:

cd shop
python receipt.py

cd .. moves back up one folder, to day13.

The from and as forms from 13.2 and 13.3 work on your own modules too:

from pricing import format_price, with_tax

print(format_price(with_tax(10)))
print(format_price(with_tax(0.99)))

$10.80
$1.07

0.99 × 1.08 is 1.0692, which :.2f shows as $1.07. You can also try your module in the REPL, as long as you start the REPL from the shop folder:

>>> import pricing
>>> pricing.TAX_RATE
0.08
>>> pricing.format_price(4)
'$4.00'
>>> pricing.format_price(pricing.with_tax(25))
'$27.00'

The REPL shows format_price’s result with quotes because it is a string; print would show it without them.

A few things happen behind the scenes:

• Where Python looks. For import pricing, Python first looks in the folder of the script you ran, then in the standard library. That is why the two files must be in the same folder.
• A module runs only once. The first import pricing runs pricing.py from top to bottom. If the program imports it again (or another module imports it), Python reuses the module it already loaded instead of running the file again.
• __pycache__. After the first import, a folder named __pycache__ appears next to your files. Python saves a ready-to-run copy of each imported module there so the next import is faster. You never edit it, and deleting it is harmless: Python makes it again.

When a project grows to many modules, you can group them into a sub-folder. A folder of modules that you import from is called a package, and you reach a module inside it with a dot, for example from shop import pricing for a folder shop holding pricing.py. You will mostly meet packages as code you install (13.10); for today, a folder of .py files that import each other is all you need.

import prices

print(prices.format_price(5))

ModuleNotFoundError: No module named 'prices'

"""My dice helpers (a bad file name: it hides the standard random module)."""


def describe(total):
    """Return a short description of a dice total."""
    return f"You rolled {total}."

import random

total = random.randint(1, 6) + random.randint(1, 6)
print(total)

AttributeError: module 'random' has no attribute 'randint' (consider renaming '.../shadow/random.py' since it has the same name as the standard library module named 'random' and prevents importing that standard library module)

When you write a module, you want to test it: call each function and check the result. The natural place for those test lines is at the bottom of the module. But 13.4 said that importing runs the module’s whole file, test lines included.

"""Temperature conversions."""


def c_to_f(celsius):
    """Return a Celsius temperature in Fahrenheit."""
    return celsius * 9 / 5 + 32


def f_to_c(fahrenheit):
    """Return a Fahrenheit temperature in Celsius."""
    return (fahrenheit - 32) * 5 / 9


print("Testing convert.py")
print(c_to_f(100))
print(f_to_c(32))

Testing convert.py
212.0
0.0

import convert

today = 25
print(f"Today: {today} C is {convert.c_to_f(today)} F")

Testing convert.py
212.0
0.0
Today: 25 C is 77.0 F

Python solves this with a special variable. Every module automatically has a variable called __name__ (two underscores on each side). Python sets it in one of two ways:

• In the file you run (python show_name.py), __name__ is the string "__main__", meaning “this is the main program”.
• In a file that is imported, __name__ is the module’s own name, such as "show_name".

Here is a one-line module that prints its own __name__, and a script that imports it:

print(f"In show_name.py, __name__ is {__name__}")

import show_name

print(f"In main.py, __name__ is {__name__}")

Running python main.py:

In show_name.py, __name__ is show_name
In main.py, __name__ is __main__

Running python show_name.py instead:

In show_name.py, __name__ is __main__

The same file prints a different __name__ depending on whether it was run or imported. So a module can ask “was I run directly?” with an ordinary Day 4 if:

if __name__ == "__main__":
    ...

Read it as “only if this file is the one being run”. This line is often called the main guard. Here is the temperature module with its tests moved under the guard:

"""Temperature conversions."""


def c_to_f(celsius):
    """Return a Celsius temperature in Fahrenheit."""
    return celsius * 9 / 5 + 32


def f_to_c(fahrenheit):
    """Return a Fahrenheit temperature in Celsius."""
    return (fahrenheit - 32) * 5 / 9


if __name__ == "__main__":
    print("Testing convert.py")
    print(c_to_f(100))
    print(f_to_c(32))

Run directly, it still tests itself:

Testing convert.py
212.0
0.0

Imported by the same weather.py, the tests stay quiet:

Today: 25 C is 77.0 F

When weather.py imports convert, __name__ in convert.py is "convert", the condition is False, and the indented block is skipped. The function definitions above the guard still run, so convert.c_to_f exists.

The main guard also belongs in main scripts. Many programmers put a script’s work in a function called main() and call it under the guard, so that even the main script can be imported (by a test, say) without starting its menu. You will see exactly that in today’s Practice.

You have used two standard library modules so far, math and statistics. The rest of today’s tour visits four more. Here is the map:

On Day 5 your guessing game’s secret number was written into the code, so the game was the same every time. Games, quizzes, and simulations need numbers the program cannot predict. The random module makes pseudo-random numbers: numbers produced by a calculation that is designed to look unpredictable.

Notice the difference from Day 5’s range: range(1, 6) stops before 6, but random.randint(1, 6) can give 6. A die is random.randint(1, 6).

Because the results change every run, a program’s exact output cannot be predicted, and this page never shows you “the” output of a random program. What you can check is the facts that hold every time:

import random

rolls = [random.randint(1, 6) for _ in range(100)]
print(f"Rolls: {len(rolls)}")
print(f"Smallest is at least 1: {min(rolls) >= 1}")
print(f"Largest is at most 6: {max(rolls) <= 6}")

Rolls: 100
Smallest is at least 1: True
Largest is at most 6: True

The other functions, checked the same way:

import random

snacks = ["apple", "pretzels", "yogurt"]
pick = random.choice(snacks)
print(f"The pick is one of the snacks: {pick in snacks}")

deck = ["A", "K", "Q", "J"]
random.shuffle(deck)
print(f"Same four cards after shuffling: {sorted(deck) == ['A', 'J', 'K', 'Q']}")

chance = random.random()
print(f"At least 0 and below 1: {0 <= chance < 1}")

The pick is one of the snacks: True
Same four cards after shuffling: True
At least 0 and below 1: True

random.choice picks one snack, a different one on different runs. random.shuffle(deck) changes the order of deck itself, like Day 6’s sort(), so after it the list holds the same four cards in some order; sorting it gives back the original cards. random.random() is handy for chances: random.random() < 0.25 is True about one time in four.

With random, the Day 5 guessing game finally gets a secret it does not know. Only the first line of the game changes (plus the import):

import random

secret = random.randint(1, 10)

Making random repeatable with seed

Unpredictable numbers make a program hard to test: if a bug shows up on one run, you may never see the same rolls again. The pseudo-random calculation starts from a value called the seed. Normally Python picks a different seed every run. random.seed(n) sets it yourself, and the same seed always gives the same sequence of numbers afterwards:

import random

random.seed(2026)
first = [random.randint(1, 6) for _ in range(10)]

random.seed(2026)
second = [random.randint(1, 6) for _ in range(10)]

print(f"Same ten rolls after the same seed: {first == second}")

Same ten rolls after the same seed: True

Both lists start right after random.seed(2026), so they are identical, and they are identical on every run of the program. Remove the second random.seed(2026) and second continues the sequence instead, so it is (almost always) different. Seed while testing; take the seed out when you want a real game. (The same seed gives the same numbers every time on the same version of Python; a different version may give different ones.)

import random

deck = ["A", "K", "Q", "J"]
deck = random.shuffle(deck)
print(deck)

None

How many days until an exam? What date is 30 days after a library book is borrowed? Doing this with plain numbers means remembering that months have 28 to 31 days and that some years are leap years. The datetime module knows the calendar for you.

It holds a few types; these are the ones you need today, usually imported with from:

>>> from datetime import date, timedelta
>>> launch = date(2026, 1, 15)
>>> launch.year
2026
>>> launch.month
1
>>> launch.weekday()
3
>>> print(launch)
2026-01-15
>>> print(launch + timedelta(days=30))
2026-02-14
>>> launch + timedelta(days=30)
datetime.date(2026, 2, 14)

• launch.year and launch.month read parts of the date, with a dot and no parentheses.
• launch.weekday() gives the day of the week as a number, with Monday as 0, so 3 means Thursday.
• print(launch) shows the date in year-month-day order, 2026-01-15.
• Adding a timedelta gives a new date. 30 days after 15 January is 14 February: Python counted January’s 31 days for you.
• In the REPL, a date that is not printed shows as datetime.date(2026, 2, 14), the code that would make it.

from datetime import date

start = date(2026, 1, 15)
exam = date(2026, 5, 11)
gap = exam - start
print(gap.days)
print(f"{gap.days // 7} weeks and {gap.days % 7} days")

116
16 weeks and 4 days

Times work the same way with datetime. To show a date or time in a chosen format, call its strftime method (“string from time”) with codes such as %d (day), %m (month), %Y (four-digit year), %H (hour, 00 to 23), and %M (minutes):

from datetime import datetime, timedelta

start = datetime(2026, 1, 15, 9, 30)
end = start + timedelta(minutes=95)
print(start.strftime("%d/%m/%Y"))
print(f"{start.strftime('%H:%M')} to {end.strftime('%H:%M')}")

15/01/2026
09:30 to 11:05

A lesson starting at 9:30 and lasting 95 minutes ends at 11:05: the timedelta carried the extra minutes into the hours. Notice the single quotes around '%H:%M' inside the f-string on line 6, because the f-string itself uses double quotes.

To get today’s date, call date.today(); for the date and time right now, call datetime.now(). Their results depend on when you run the program, so this page never shows them: run print(date.today()) yourself and you will see your own date.

import datetime

meeting = datetime(2026, 1, 15, 9, 30)
print(meeting)

TypeError: 'module' object is not callable. Did you mean: 'datetime.datetime(...)'?

from datetime import date, timedelta

order = date(2026, 2, 27)
arrives = order + timedelta(days=3)
print(arrives)
print((arrives - order).days)

2026-03-02
3

Your programs so far have lived in their own world of variables. Sometimes a program needs to ask about the computer around it: which folder is the terminal in? Does a file exist? What did the user type after the program’s name? Two standard modules answer these questions.

os: files and folders

The os module (“operating system”) talks to the computer’s files and folders. A few everyday functions:

The answers depend on your computer, so os.getcwd() and os.listdir(".") print something different for everyone; try them in your day13 folder. A file name with no folder in front, like "pricing.py", means “in the current working directory”. That is why Day 1 told you to run scripts from the folder that holds them. In the shop folder from 13.4:

import os

for name in ["pricing.py", "prices.py"]:
    print(f"{name} is here: {os.path.exists(name)}")

Run from the shop folder:

pricing.py is here: True
prices.py is here: False

os.path is the part of os for file names and paths; Day 14 does much more with files and paths.

sys: the running program

The sys module (“system”) holds facts about the running Python program. The most useful is sys.argv, the list of command-line arguments: the words typed in the terminal to start the program. Item 0 is always the script’s name:

import sys

print(sys.argv)
print(len(sys.argv))

Run with python argv_demo.py:

['argv_demo.py']
1

Any extra words you type after the file name are added to the list as strings. Run with python argv_demo.py Ana 15:

['argv_demo.py', 'Ana', '15']
3

So a program can take its input from the command line instead of from input(). sys.exit(message) ends the program at once, printing the message as an error:

import sys

if len(sys.argv) < 2:
    sys.exit("Usage: python greet_args.py NAME")

name = sys.argv[1]
print(f"Hello, {name}!")

Run with no extra words, python greet_args.py:

Usage: python greet_args.py NAME

sys.argv has only one item, so line 4 stops the program with a usage message, the traditional way to tell someone how to run a command. Running python greet_args.py Ana instead skips the if, takes sys.argv[1], which is "Ana", and greets Ana.

sys also tells a program where it is running: sys.platform is a short string naming the operating system (such as "win32", "darwin" for macOS, or "linux"), and sys.version describes the version of Python. Print them on your own computer to see yours.

The standard library is big, but not everything is in it. Thousands of people publish their own modules for anyone to use, such as tools for fetching web pages or drawing charts. Code written by someone other than you or the Python team is third-party code. Before you install any of it, you need a place to put it.

Imagine two projects. An old one needs version 1 of a charting package; a new one needs version 2, which works differently. If both projects share one Python installation, only one version can be installed at a time, and upgrading for the new project breaks the old one. Installing into the Python that came with your computer can also break programs your operating system relies on, and some systems refuse to let you try.

A virtual environment is a private, project-only copy of Python’s install space: a folder inside your project that holds its own python command and its own installed packages. Packages installed while it is active go into that folder and nowhere else. Each project gets its own, so projects can never break each other. The standard library’s venv module creates one.

The commands below go in the terminal, not in the REPL. Start in your project’s folder (for today, day13).

1. Create it (once per project):

python -m venv .venv

-m venv means “run the venv module as a program”. .venv is the name of the folder to create; the leading dot is the usual choice, and some systems hide names starting with a dot. On macOS and Linux, use python3 if python is not found; on Windows, py works too (Day 1).

2. Activate it (in each new terminal you open). The command depends on your system:

macOS and Linux:
source .venv/bin/activate

Windows (PowerShell):
.venv\Scripts\Activate.ps1

Windows (Command Prompt):
.venv\Scripts\activate.bat

To activate a virtual environment means to tell this terminal to use its python and its packages. Once it is active, the prompt shows the environment’s name in parentheses, such as (.venv), and the plain command python means the environment’s Python on every system, even where you normally type python3 or py.

If PowerShell refuses with a message that running scripts is disabled on this system, run this once, then activate again:

Set-ExecutionPolicy -Scope CurrentUser RemoteSigned

3. Work. Run your scripts as usual (python receipt.py). VS Code also notices a .venv folder in the open project and offers to use it.

4. Deactivate when you are done:

deactivate

The (.venv) disappears, and python means your normal Python again. Closing the terminal also ends it.

Three rules keep environments simple:

• One per project, in the project’s folder, named .venv.
• Never put your own code inside .venv, and never edit files in it. Your scripts stay beside it.
• Do not share .venv. It is large and only works on the computer that made it. Share a list of what to install instead (13.10), and anyone can rebuild it with one command.

Third-party code is published on the Python Package Index, PyPI (pypi.org), a free public library of hundreds of thousands of packages. A package, in this sense, is a bundle of modules that someone has published so others can install it. The tool that downloads and installs packages from PyPI is pip, and it comes with Python.

With your virtual environment active, install a package by name. requests, a popular package for fetching web pages (Day 22 uses it), makes a good first one:

python -m pip install requests

python -m pip means “run pip with this Python”, which, with (.venv) showing, is the environment’s Python, so the package lands in .venv. You will see pip download files and then a line that starts with Successfully installed. Packages often depend on other packages; pip installs those too, so the message may list several names. Once installed, the package is imported like any module: import requests.

Other pip commands you will use:

requirements.txt

13.9 said not to share .venv. Instead, a project keeps a short text file, named requirements.txt by convention, that lists the packages it needs, one per line. You can write it by hand:

requests

or let pip write it with python -m pip freeze > requirements.txt. freeze prints each installed package as its name, two equals signs, and the exact version (requests== then the version number), and > is a terminal feature that sends that output into the file instead of the screen. Pinning exact versions this way means everyone who rebuilds the project gets the same versions you tested with.

Someone who downloads your project then rebuilds the environment with three commands (shown for macOS and Linux; use the Windows activate command from 13.9 on Windows):

python -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements.txt

The project folder, then, looks like this: your .py files, requirements.txt beside them, and a .venv folder that each person makes on their own computer.

A student wants to plan reading for an exam: how many days are left, how many pages to read each day, and a schedule. The planning functions go in a module, and a short main script uses them. Make a folder day13/exam_planner/ with two files:

"""Study planning helpers: days left, pages per day, and a schedule."""

import math
from datetime import timedelta


def days_between(start, end):
    """Return the number of days from start to end."""
    return (end - start).days


def pages_per_day(pages, days):
    """Return the pages to read each day to finish in time, rounded up."""
    return math.ceil(pages / days)


def schedule(start, days, pages_each):
    """Return a list of (date, pages) pairs, one for each study day."""
    return [(start + timedelta(days=offset), pages_each) for offset in range(days)]


if __name__ == "__main__":
    from datetime import date

    print(days_between(date(2026, 3, 1), date(2026, 3, 31)))
    print(pages_per_day(100, 30))

from datetime import date

import planner

start = date(2026, 4, 20)
exam = date(2026, 5, 11)
pages = 250

days = planner.days_between(start, exam)
each = planner.pages_per_day(pages, days)
print(f"{days} days until the exam: read {each} pages a day.")
for day, amount in planner.schedule(start, 3, each):
    print(f"{day.strftime('%d/%m')}: {amount} pages")
print("...")

Running python main.py from the exam_planner folder:

21 days until the exam: read 12 pages a day.
20/04: 12 pages
21/04: 12 pages
22/04: 12 pages
...

Running python planner.py runs its self-test instead:

30
4

• The self-test checks March, which has 31 days: from 1 to 31 March is 30 days, and 100 pages over 30 days is 3.33…, rounded up to 4. Rounding down to 3 a day would leave 10 pages unread on exam day.
• main.py uses fixed dates so that this page can show its output. In real use, start = date.today() (13.7) makes the plan start from the day you run it.
• The self-test needs date but the module’s functions do not, so from datetime import date sits inside the guard. Imports usually go at the top, but an import only the self-test uses can live with the self-test.

• A module is a file of Python code. import math creates the name math (use math.sqrt); from math import sqrt creates only sqrt; as picks the name an import creates.
• Every .py file you write is a module, so a project can be split into a module of functions and a main script that imports it, kept in the same folder. Never name a file after a module you import.
• __name__ is "__main__" only in the file being run, so code under if __name__ == "__main__": runs when the file is run but not when it is imported.
• The standard library covers everyday jobs: math (sqrt, ceil, floor, pi), random (randint includes both ends, choice, shuffle, seed), datetime (date, timedelta, strftime), os (folders and files), and sys (argv, exit).
• A virtual environment (python -m venv .venv, then activate) gives each project its own installed packages. With it active, python -m pip install adds packages from PyPI, and requirements.txt records them so anyone can rebuild the environment.

Do these in your day13 folder. Type each program yourself, run it, and only then open the answer.

"""Task functions for the to-do manager. main.py imports them."""


def show_menu():
    """Print the menu of choices."""
    print()
    print("1) Add  2) List  3) Complete  4) Delete  5) Quit")


def add_task(tasks, title):
    """Add a new, unfinished task to the end of tasks."""
    tasks.append({"title": title, "done": False})


def list_tasks(tasks):
    """Print every task with its number and a check box."""
    if not tasks:
        print("No tasks yet.")
        return
    for number, task in enumerate(tasks, 1):
        mark = "x" if task["done"] else " "
        title = task["title"]
        print(f"{number}. [{mark}] {title}")


def complete_task(tasks, number):
    """Mark task number (counting from 1) as done.

    Return the task, or None if no task has that number.
    """
    if not 1 <= number <= len(tasks):
        return None
    task = tasks[number - 1]
    task["done"] = True
    return task


def delete_task(tasks, number):
    """Remove task number (counting from 1) from tasks.

    Return the removed task, or None if no task has that number.
    """
    if not 1 <= number <= len(tasks):
        return None
    return tasks.pop(number - 1)


if __name__ == "__main__":
    test_tasks = []
    add_task(test_tasks, "Test the module")
    print(complete_task(test_tasks, 1))
    print(complete_task(test_tasks, 2))
    list_tasks(test_tasks)

{'title': 'Test the module', 'done': True}
None
1. [x] Test the module

"""The to-do manager's menu loop. Run this file to start the program."""

from tasks import add_task, complete_task, delete_task, list_tasks, show_menu


def main():
    """Run the menu loop until the user chooses Quit."""
    tasks = []
    print("To-do list manager")
    while True:
        show_menu()
        choice = input("Choose 1-5: ").strip()
        if choice == "1":
            title = input("Task title: ").strip()
            if title:
                add_task(tasks, title)
                print(f"Added: {title}")
            else:
                print("A task needs a title.")
        elif choice == "2":
            list_tasks(tasks)
        elif choice in ("3", "4"):
            text = input("Task number: ").strip()
            if not text or not all(ch in "0123456789" for ch in text):
                print("Please type a task number, such as 1.")
                continue
            number = int(text)
            if choice == "3":
                task = complete_task(tasks, number)
                action = "Completed"
            else:
                task = delete_task(tasks, number)
                action = "Deleted"
            if task is None:
                print(f"There is no task {number}.")
            else:
                title = task["title"]
                print(f"{action}: {title}")
        elif choice == "5":
            print("Goodbye!")
            break
        else:
            print("Please choose a number from 1 to 5.")


if __name__ == "__main__":
    main()

To-do list manager

1) Add  2) List  3) Complete  4) Delete  5) Quit
Choose 1-5: 1
Task title: Buy milk
Added: Buy milk

1) Add  2) List  3) Complete  4) Delete  5) Quit
Choose 1-5: 1
Task title: Read Day 13
Added: Read Day 13

1) Add  2) List  3) Complete  4) Delete  5) Quit
Choose 1-5: 3
Task number: 1
Completed: Buy milk

1) Add  2) List  3) Complete  4) Delete  5) Quit
Choose 1-5: 4
Task number: first
Please type a task number, such as 1.

1) Add  2) List  3) Complete  4) Delete  5) Quit
Choose 1-5: 2
1. [x] Buy milk
2. [ ] Read Day 13

1) Add  2) List  3) Complete  4) Delete  5) Quit
Choose 1-5: 5
Goodbye!

import random

random.seed(13)  # Delete this line to get different rolls on every run.

tally = {}
for _ in range(1000):
    total = random.randint(1, 6) + random.randint(1, 6)
    tally[total] = tally.get(total, 0) + 1

for total in sorted(tally):
    count = tally[total]
    print(f"{total:2}: {count:3} {'#' * (count // 10)}")

print(f"Rolls counted: {sum(tally.values())}")
print(f"Every total is from 2 to 12: {all(2 <= total <= 12 for total in tally)}")

 2:  26 ##
 3:  48 ####
 4:  96 #########
 5: 126 ############
 6: 138 #############
 7: 156 ###############
 8: 138 #############
 9: 118 ###########
10:  72 #######
11:  59 #####
12:  23 ##
Rolls counted: 1000
Every total is from 2 to 12: True

python -m venv .venv
source .venv/bin/activate
python -m pip install requests
python -m pip list

print("Loading helpers")


def double(number):
    """Return twice the number."""
    return number * 2


if __name__ == "__main__":
    print("Testing:", double(4))

import helpers
import helpers

print("App starts")
print(helpers.double(21))

Loading helpers
App starts
42

from datetime import date

deadline = datetime.date(2026, 3, 1)
print(deadline)

NameError: name 'datetime' is not defined. Did you forget to import 'datetime'?

from datetime import date

deadline = date(2026, 3, 1)
print(deadline)

2026-03-01

import math
from datetime import date

start = date(2026, 6, 1)
end = date(2026, 7, 1)
days = (end - start).days
print(days)
print(days / 7)
print(math.ceil(days / 7))

30
4.285714285714286
5

import math as m
from random import randint

The official Python Tutorial covers modules, __name__, and packages in Modules, and environments and pip in Virtual Environments and Packages. Its Brief Tour of the Standard Library shows more modules than today’s tour.

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can import a module and use its functions with a dot. Reread
• I can choose between math.ceil, math.floor, and round. Reread
• I can say which names from ... import creates. Reread
• I can give an import a different name with as. Reread
• I can split a program into a module and a main script in one folder. Reread
• I can explain what if __name__ == "__main__" does and when to use it. Reread
• I can use randint, choice, shuffle, and seed, and say what output is certain. Reread
• I can make dates, add a timedelta, and find the days between two dates. Reread
• I can check for a file with os and read command-line arguments with sys. Reread
• I can create, activate, and deactivate a virtual environment. Reread
• I can install a package with pip and record it in requirements.txt. Reread