This is Data Science

Conclusion

This guide walked through the end-to-end setup of a professional Python development environment on macOS — starting from a bare machine and arriving at a fully functioning, version-controlled, notebook-ready workspace. Here is a recap of everything accomplished.

What Was Set Up

  • Chapter 2 — Command Line Tools: Apple's Xcode CLT was installed using xcode-select --install. This activated the system's developer directory and made essential tools such as git, make, and python3 available from the terminal.
  • Chapter 3 — Homebrew: The Homebrew package manager was installed via its official shell script. Homebrew serves as the foundation for all subsequent software installations on macOS, handling downloads, dependencies, and upgrades in a consistent and reproducible way.
  • Chapter 4 — Python baseline: The system Python was identified and deliberately left untouched. The guide established that all project-level Python versions should be managed through pyenv rather than installed directly into the system.
  • Chapter 5 — pyenv and pyenv-virtualenv: Both tools were installed via Homebrew and the shell (zsh) was configured to initialise pyenv on every session. The ~/.zprofile and ~/.zshrc files were updated so that pyenv shims take priority over system Python, and virtual environments activate automatically when entering a project directory.
  • Chapter 6 — Python version management: Two Python versions (3.8.10 and 3.9.5) were installed using pyenv install. A global default (3.8.10) was set with pyenv global, and a per-directory override (3.9.5) was applied inside the Projects folder using pyenv local. The guide also covered how to resolve the lzma module warning that can appear with Python 3.10 and later.
  • Chapter 7 — Virtual environments: A project-level virtual environment (venv-dummy) was created using pyenv virtualenv, pinned as the local default, and used to install numpy in complete isolation. The guide demonstrated that packages installed inside a virtual environment are inaccessible from any other environment on the machine, and showed how pyenv virtualenv-init enables automatic activation.
  • Chapter 8 — Jupyter kernels and notebooks: JupyterLab was installed globally and then inside a dedicated virtual environment (venv-exp-all). A named ipykernel was registered for that environment, making it selectable from the JupyterLab launcher. The experiments confirmed that packages installed in one kernel are not visible in others, validating true notebook-level isolation.
  • Chapter 9 — GitHub and version control: A set of SSH key-pair was generated for different GitHub accounts using ssh-keygen with the modern ed25519 algorithm. The public keys were added to respective GitHub accounts, and the connection was verified. Further, multiple project directories were created and Git configurations was updated to ensure correct identity resolution while using multiple GitHub profiles from same machine.

The Complete Stack at a Glance

After completing this guide, your machine has the following toolchain in place:

  • Xcode CLT — developer utilities and compiler toolchain
  • Homebrew — macOS package manager for installing and updating software
  • pyenv — Python version manager; installs and switches between any Python version
  • pyenv-virtualenv — virtual environment manager; isolates packages per project
  • JupyterLab — interactive notebook environment for data exploration
  • ipykernel — bridges virtual environments to Jupyter kernel instances
  • Git + GitHub SSH — version control with authenticated remote collaboration

Next Steps

With this foundation in place, you are well positioned to begin serious data science and software development work on macOS. A few natural next steps to consider:

  • Create a requirements.txt or pyproject.toml for each project to pin exact dependency versions and make environments reproducible across machines.
  • Set up a code editor such as VS Code or PyCharm and configure it to use the project's pyenv virtual environment as its Python interpreter.
  • Explore Docker for heavier isolation needs — particularly when your project has non-Python system dependencies or needs to run identically in CI/CD.
  • Configure pre-commit hooks (e.g. black, flake8, isort) to enforce code style automatically before each git commit.

Happy Coding!!