Projects, Environments & Dependencies.

Python Fundamentals taught you to write functions and report on fictional IT data. Applied Python is where you turn those functions into a project that can be run again, tested and maintained on your own computer.

• Organize a small Python project with source, sample data, setup instructions and .gitignore.
• Identify the active Python interpreter and distinguish environment isolation from a security sandbox.
• Create and use a virtual environment using the correct command for Windows PowerShell, Windows CMD or macOS/Linux shells.
• Target pip at the selected Python interpreter and distinguish standard-library from third-party packages.
• Document direct dependency requirements without confusing pip freeze with a curated project manifest.
• Separate importable helper functions from the main() entry point.
• Run and verify a standard-library-only report locally with fictional data, then compare its behavior with browser exercises.

Prerequisite: Complete Python Fundamentals or be comfortable with functions, loops, collections, exceptions and JSON. You can review the optional Run Python on Your Computer guide if you haven't run a local script yet.

A one-file script is a good starting point, but maintaining even a small tool means tracking its source code, setup instructions, dependencies and generated output. Give the project a directory, a clear entry point such as inventory_report.py, and a README describing what the tool does and how to run it. Keep sample input separate from output, and keep secrets out of your source files. That organization lets someone else understand and reproduce your work instead of depending on your computer's history.

from pathlib import Path
project = Path('northstar-report')
print(project.name)
print(project / 'samples' / 'inventory.json')

mkdir northstar-python-tool
cd northstar-python-tool

python --version
python -c "import sys; print(sys.executable)"
python -m pip --version

A machine can have more than one Python installation, and a project can have its own virtual environment. The python executable is the interpreter that runs your code; it is not the same thing as your editor. sys.executable shows the interpreter path, sys.version_info reports its version, and sys.prefix versus sys.base_prefix helps identify whether a standard virtual environment is active. Do not judge success solely by a prompt that looks like (.venv); inspect the interpreter actually executing your script.

import sys
print(sys.version_info.major)
print(sys.version_info.minor)
print(bool(sys.executable))

A Python virtual environment keeps a project's third-party packages separate from other projects and from the system installation. From the project folder, use the standard-library venv module to create .venv, then use that environment's interpreter. The environment is a working tool you can recreate, not something to commit to Git. It is not a security sandbox and does not isolate network access, secrets, or operating-system permissions. Creating and activating this environment is a real local-terminal task—not an action the JoeLearns browser editor performs.

import sys
# Inspect the interpreter running this code:
is_venv = sys.prefix != sys.base_prefix
print(type(is_venv).__name__)

mkdir northstar-python-tool
cd northstar-python-tool

The activation command depends on your operating system and shell. On Windows PowerShell, use .\.venv\Scripts\Activate.ps1; in Windows Command Prompt, use .venv\Scripts\activate.bat. On macOS/Linux with bash or zsh, use source .venv/bin/activate. Once activated, python -m pip installs into the active interpreter. In Windows PowerShell, where.exe python reveals executable lookup; where python by itself is a different PowerShell alias. If a managed device blocks script activation, do not loosen security policy—call the environment's python executable directly or ask the administrator.

from pathlib import PurePosixPath
print(str(PurePosixPath('.venv/bin/python')))
print('Activation is optional')

The Python standard library includes modules such as json, csv, pathlib and argparse. Third-party distribution packages such as requests come from a package index or other trusted source and are installed with pip. A distribution package name may differ from the Python import name, and packages can bring other dependencies. Prefer python -m pip over an unqualified pip command so the installation targets the interpreter you've chosen. Check package provenance and approved versions before installing anything on a managed system.

import json
import csv
import pathlib
print(json.dumps({'modules': ['json','csv','pathlib']}, sort_keys=True))

import sys

names = sys.stdlib_module_names
print('json' in names)
print('csv' in names)
print('requests' in names)

A requirements.txt file can list third-party distribution requirements for a project. For example, requests>=2.32,<3 expresses a compatible version range rather than a single exact version; whether that range is appropriate depends on what your project supports and your security maintenance process. python -m pip install -r requirements.txt installs those dependencies into the chosen environment. pip freeze captures what's currently installed, including transitive packages, but its output isn't automatically a carefully maintained or reproducible lock file. This first project uses standard-library modules, so it has no third-party dependency to install.

requirements = '# standard-library-only project\n'
active = [line for line in requirements.splitlines()
          if line.strip() and not line.lstrip().startswith('#')]
print(len(active))

A practical project benefits from small functions that can be imported and tested separately from its command-line entry point. A module can live in another .py file in your project folder. Use import or from ... import to reuse it, and place executable program behavior under if __name__ == '__main__': so importing the module does not accidentally launch a report or modify files. This expands the Files, Exceptions & Modules foundation by focusing on how an actual project stays maintainable.

def summarize_hosts(hosts):
    return f'{len(hosts)} hosts'

def main():
    print(summarize_hosts(['SW-01', 'AP-02']))

if __name__ == '__main__':
    main()

from pathlib import PurePosixPath

path = PurePosixPath('src/__pycache__/report.pyc')
print(path.parts)
print(path.suffix)
print('__pycache__' in path.parts)

A project isn't ready because a package installation printed 'Successfully installed'. Verify the interpreter, run the script, inspect its output, and record the exact steps in your README. For this first project, write a tiny inventory_report.py that reads fictional inventory data using the standard library, prints a deterministic count, and exits without network connections or credentials. Test an empty inventory and a changed one. The browser challenges let you practice its component functions, while the optional local setup guide shows how to run and inspect the real project on your computer.

import json
samples = json.loads('[{"host":"SW-01"},{"host":"AP-02"}]')
print(f'{len(samples)} hosts')

Return to the Project Setup Explorer above and follow its steps with fictional data. Verify that the selected interpreter belongs to your project's .venv and that the sample script prints 2 devices / 1 offline. Then change an input status and verify the report changes. Record the commands you used in README.md.

Avoid installing third-party packages until they're necessary; the first project uses json from Python's standard library. When later lessons introduce API clients, install only trusted, approved dependencies into the correct environment.

The browser clinic checks interpreter inspection, dependency reasoning, safe project-file classification, reusable entry points and a structured inventory report. Finish the first task below, then complete all six in the coding clinic. Browser code runs without accessing your actual files.

The packaging and interpreter instructions are grounded in maintained Python documentation. Shell command details vary by operating system and installation; verify commands against your own environment.