Chapter 2: Setting Up Your Development Environment

Let's be honest: setup chapters are boring. You want to make API requests and see data appear on your screen, not configure tools and install software. But here's the reality, the next 30 minutes you invest in proper setup will save you hours of frustration later.

Professional developers spend significant time on their development environment because the right setup makes everything easier. You'll write code faster, debug problems more efficiently, and avoid countless "why isn't this working?" moments that have nothing to do with your code and everything to do with misconfigured tools.

This chapter is designed differently from most setup guides. Instead of assuming everything will work perfectly, I've built in troubleshooting for the most common problems. When something doesn't work (and statistically, something won't), you'll know exactly how to fix it.

Before diving into installation, let's understand what you're setting up:

Here's how this chapter works:

If you encounter an error that's not covered in troubleshooting, don't panic. Copy the error message (without personal file paths), search it on Google, and you'll find solutions. Millions of people have set up Python before you, every error has been solved and documented.

By the end of this chapter, you'll be able to:

• Verify that Python 3.8 or higher is installed correctly on your system and understand how to check versions.
• Create and activate virtual environments to isolate project dependencies and prevent conflicts.
• Use pip to install Python packages properly within virtual environments.
• Set up a professional code editor (VS Code) with Python extensions for an optimal development experience.
• Navigate the command line confidently to manage files, run scripts, and troubleshoot common setup issues.
• Make your first successful API call to verify your environment is working correctly.

Before installing anything, let's see what's already on your system. You might have Python installed without knowing it. This section takes less than 2 minutes and could save you from unnecessary installation steps.

You'll use the command line throughout this book. It's a text interface where you type commands instead of clicking buttons. Don't worry, it's more straightforward than it looks.

You'll see a window with text and a cursor. This is where you'll type commands. Each command does one thing, when you press Enter, your computer executes it.

With your command line open, let's check if Python is installed:

Type this command and press Enter:

python --version

Python 3.11.4

Any version starting with 3.8 or higher is perfect. Skip to "Checking for pip" below.

Python 2.7.18

Python 2 is outdated and won't work with modern libraries. Try python3 --version instead. If that shows Python 3.8+, use python3 instead of python for all commands in this book.

'python' is not recognized as an internal or external command

Or on Mac/Linux:

command not found: python

Python isn't installed or isn't in your PATH. Go to Troubleshooting Issue #1 at the end of this chapter.

pip is Python's package installer. It usually comes with Python, but let's verify:

pip --version

Or if you're using python3:

pip3 --version

pip 23.2.1 from /usr/local/lib/python3.11/site-packages/pip (python 3.11)

The exact numbers don't matter. As long as you see a version number and it mentions Python 3.8+, you're good.

'pip' is not recognized as an internal or external command

Go to Troubleshooting Issue #2 at the end of this chapter.

Professional developers keep their projects organized in dedicated folders. This makes code easier to find, back up, and share. You're going to create a single folder that will hold all your API projects for this book.

Think of this as creating a dedicated workspace on your computer. Everything related to this book and your API learning journey will live in one place. When you come back to work on projects later, you'll know exactly where to find them.

Follow these commands in order. Each command is explained after the code block.

cd %USERPROFILE%

mkdir api-projects

cd api-projects

cd

You should see something like: C:\Users\YourName\api-projects

Follow these commands in order:

cd ~

mkdir api-projects

cd api-projects

pwd

You should see something like: /Users/YourName/api-projects or /home/yourname/api-projects

This is the most important part of your development environment setup. Virtual environments prevent the dependency conflicts that plague beginners and cause mysterious "it worked yesterday" problems.

Every Python project should have its own virtual environment. This isolates each project's libraries from your system Python and from other projects. It's a best practice that professional developers follow religiously, and you're going to adopt it from day one.

Make sure you're in your api-projects folder (if not, use cd ~/api-projects or cd %USERPROFILE%\api-projects). Then create your first virtual environment:

python -m venv my-first-api-env

python3 -m venv my-first-api-env

This command creates a new folder called my-first-api-env that contains a complete, isolated Python installation. It takes 10-30 seconds to complete. You won't see any output unless there's an error.

Creating the virtual environment isn't enough, you need to activate it. Think of activation as "turning on" your isolated Python workspace. When activated, any packages you install go into this environment instead of your system Python.

my-first-api-env\Scripts\activate

source my-first-api-env/bin/activate

After activation, you'll see the environment name in parentheses at the start of your command prompt:

(my-first-api-env) C:\Users\YourName\api-projects>

(my-first-api-env) YourName@computer:~/api-projects$

That (my-first-api-env) prefix is your visual confirmation that the environment is active. Always look for this before installing packages or running Python code. If you don't see it, your environment isn't active.

Here's what your typical work session will look like:

# 1. Navigate to your projects folder
cd ~/api-projects

# 2. Activate your virtual environment  
source my-first-api-env/bin/activate

# 3. Now you're ready to work
# - Install packages with pip
# - Run Python scripts
# - Work on your projects

# 4. When finished, deactivate (optional)
deactivate

The deactivate command returns you to your system Python. However, it's perfectly fine to leave your virtual environment active. Many developers keep it active all day while working on a project.

When you're done working, you can deactivate your virtual environment:

deactivate

The (environment-name) prefix disappears, and you're back to using your system Python. Closing your terminal window also deactivates the environment automatically, the next time you open a terminal, you'll need to activate again.

Many developers never manually deactivate. They simply close the terminal when done or keep the environment active while working on the project. Either approach is fine.

Python's built-in tools for making HTTP requests are verbose and difficult to use. The requests library simplifies everything, making API calls feel natural and intuitive. It's so popular that it's considered the de facto standard for HTTP in Python.

import urllib.request
import json

url = "https://api.example.com/data"
request = urllib.request.Request(url)
request.add_header('Content-Type', 'application/json')

try:
    response = urllib.request.urlopen(request)
    data = json.loads(response.read().decode('utf-8'))
except Exception as e:
    print(f"Error: {e}")

import requests

url = "https://api.example.com/data"
response = requests.get(url, timeout=10)
data = response.json()

The requests library reduces 10+ lines of boilerplate to just 3 lines of readable code. Headers, encoding, JSON parsing, error handling, it all just works. This is why professional Python developers universally prefer requests.

CRITICAL: Make sure your virtual environment is activated before installing. Look for the (my-first-api-env) prefix in your terminal. If you don't see it, activate the environment now.

pip install requests

Collecting requests
  Downloading requests-2.31.0-py3-none-any.whl (62 kB)
Collecting charset-normalizer<4,>=2
  Downloading charset_normalizer-3.2.0-cp311-cp311-macosx_11_0_arm64.whl
Collecting idna<4,>=2.5
  Downloading idna-3.4-py3-none-any.whl (61 kB)
Collecting urllib3<3,>=1.21.1
  Downloading urllib3-2.0.4-py3-none-any.whl (123 kB)
Collecting certifi>=2017.4.17
  Downloading certifi-2023.7.22-py3-none-any.whl (158 kB)
Installing collected packages: urllib3, idna, charset-normalizer, certifi, requests
Successfully installed certifi-2023.7.22 charset-normalizer-3.2.0 idna-3.4 requests-2.31.0 urllib3-2.0.4

The installation downloads requests and its dependencies. This takes 10-30 seconds depending on your internet speed. You'll see a "Successfully installed" message when it's done.

Let's confirm requests is installed and working correctly:

With your virtual environment still active, type:

python

Or on Mac/Linux if you're using python3:

python3

You'll see Python's interactive prompt: >>>

>>> import requests
>>> requests.__version__

2.31.0

If you see a version number, congratulations! requests is installed and ready to use. The exact version number doesn't matter as long as it's 2.20 or higher.

If you see this error:

>>> import requests
ModuleNotFoundError: No module named 'requests'

This means requests isn't installed in your current Python environment. The most common cause: you installed it with your virtual environment activated, but then deactivated and restarted Python without reactivating. Go to Troubleshooting Issue #7.

>>> exit()

This returns you to your normal command prompt (still with your virtual environment active).

You need a place to write Python code. While you could technically use Notepad or TextEdit, a proper code editor makes programming dramatically easier. I recommend Visual Studio Code (VS Code), it's free, powerful, works on all platforms, and has excellent Python support.

That said, if you already use another editor (PyCharm, Sublime Text, Atom, Vim, Emacs), stick with what you know. The key is having somewhere to write and save Python files with .py extensions.

1. Go to code.visualstudio.com
2. Download the installer for your operating system
3. Run the installer (accept all default settings)
4. Launch VS Code

First launch takes a few extra seconds as VS Code sets itself up. Once it opens, you'll see a clean interface with a sidebar on the left and a main editor area.

VS Code becomes significantly more powerful with the Python extension installed:

1. Click the Extensions icon in the left sidebar (looks like four squares)
2. Search for "Python"
3. Find the extension by Microsoft (it's usually first)
4. Click "Install"

This extension adds syntax highlighting, error detection, code completion, debugging, and automatic formatting. It's what transforms VS Code from a text editor into a Python IDE.

Let's verify everything works by creating and running a simple Python file:

print("Hello from my API workspace!")

python test.py

Hello from my API workspace!

If you see the message, everything works! You can write code in VS Code and run it from your terminal. This is the workflow you'll use throughout the book.

• Integrated Terminal: View → Terminal opens a command line inside VS Code. This is often more convenient than switching between windows.
• Auto-save: File → Auto Save enables automatic file saving. This prevents lost work.
• Python Interpreter: VS Code may ask you to select a Python interpreter. Choose the one inside your my-first-api-env folder.
• Formatting: Right-click → Format Document makes code clean and consistent. Keyboard shortcut: Shift+Alt+F (Windows/Linux) or Shift+Option+F (Mac).

You don't need to master VS Code immediately. You'll learn features naturally as you write more code. For now, just being able to create files, write code, and save them is enough.

Before moving to Chapter 3, let's verify your entire setup with a comprehensive test script. This will confirm that Python, virtual environments, and the requests library all work together correctly.

Create a new file called setup_test.py in your api-projects folder and add this code:

"""
Development Environment Verification Script
This script tests that your Python environment is correctly configured
"""

import sys
import os

def test_python_version():
    """Check Python version meets minimum requirements"""
    version = sys.version_info
    print(f"✓ Python {version.major}.{version.minor}.{version.micro}")
    
    if version.major >= 3 and version.minor >= 8:
        return True
    else:
        print("✗ Python 3.8 or higher required")
        return False

def test_virtual_environment():
    """Check if running in a virtual environment"""
    in_venv = hasattr(sys, 'real_prefix') or (
        hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix
    )
    
    if in_venv:
        print("✓ Virtual environment active")
        return True
    else:
        print("⚠ Warning: Not running in virtual environment")
        return False

def test_requests_library():
    """Check if requests library is installed"""
    try:
        import requests
        print(f"✓ requests library {requests.__version__}")
        return True
    except ImportError:
        print("✗ requests library not found")
        return False

def test_api_connection():
    """Test actual API connection"""
    try:
        import requests
        response = requests.get("https://httpbin.org/get", timeout=5)
        
        if response.status_code == 200:
            print("✓ API connection successful")
            return True
        else:
            print(f"✗ API returned status code {response.status_code}")
            return False
            
    except requests.exceptions.RequestException as e:
        print(f"✗ API connection failed: {e}")
        return False

def run_all_tests():
    """Run all verification tests"""
    print("=" * 50)
    print("Development Environment Verification")
    print("=" * 50)
    print()
    
    results = []
    results.append(test_python_version())
    results.append(test_virtual_environment())
    results.append(test_requests_library())
    results.append(test_api_connection())
    
    print()
    print("=" * 50)
    
    if all(results):
        print("✓ All tests passed! You're ready for Chapter 3!")
    else:
        print("⚠ Some tests failed. Please review the issues above.")
    
    print("=" * 50)

if __name__ == "__main__":
    run_all_tests()

python setup_test.py

==================================================
Development Environment Verification
==================================================

✓ Python 3.11.4
✓ Virtual environment active
✓ requests library 2.31.0
✓ API connection successful

==================================================
✓ All tests passed! You're ready for Chapter 3!
==================================================

If all four tests pass, your development environment is correctly configured and you're ready to start building real API applications in Chapter 3.

If you see any ✗ marks, here's what they mean:

• Python version test fails: Your Python version is below 3.8. Install a newer version using the guide in Troubleshooting Issue #1.
• Virtual environment warning: You're not running in an activated virtual environment. Activate it with source my-first-api-env/bin/activate (Mac/Linux) or my-first-api-env\Scripts\activate (Windows), then run the test again.

⚠ Warning: Not running in virtual environment

This warning means your tests might pass, but you're not following best practices. Always activate your virtual environment before working on projects.

• requests library not found: The requests library isn't installed. Make sure your virtual environment is active, then run pip install requests.
• API connection failed: Your internet connection might be down, or httpbin.org might be temporarily unavailable. Try again in a few minutes. If it persists, check your firewall or proxy settings.

This chapter wasn't just about installation, it was about building professional habits. Let's review the practices that separate beginners from professional developers.

You created a dedicated api-projects folder in a consistent location. This isn't arbitrary, it's how professionals keep code organized:

• Predictable location: ~/api-projects or %USERPROFILE%\api-projects means you always know where to find your work
• Easy backups: One folder to backup instead of code scattered across your system
• Simple navigation: cd ~/api-projects becomes automatic muscle memory
• Clear separation: Your API projects are separate from other code, school assignments, or personal scripts

Professional developers often have a ~/projects or ~/code folder where all their work lives. You're establishing this habit from day one.

The most important habit you learned: ALWAYS activate your virtual environment before working. This prevents the most common beginner problems:

This three-step ritual becomes automatic with practice. Do it enough times and you'll feel uncomfortable working without it, which is exactly the mindset that prevents bugs.

cd ~/api-projects  # Mac/Linux
source my-first-api-env/bin/activate  # Mac/Linux

cd %USERPROFILE%\api-projects  # Windows
my-first-api-env\Scripts\activate  # Windows

cd ~/api-projects && source my-first-api-env/bin/activate

cd %USERPROFILE%\api-projects && my-first-api-env\Scripts\activate

You installed the requests library instead of using Python's built-in urllib. This demonstrates an important principle: choose tools that make your code readable and maintainable.

Professional developers prioritize code clarity. The requests library lets you write API calls that are immediately understandable, even months later or by other developers. Compare:

This lesson extends beyond just requests. When you have a choice between a verbose built-in approach and a clearer third-party library, favor clarity. Your future self will thank you.

You tested your setup with a verification script. This is another professional practice: verify your assumptions, don't assume things work.

The setup test script checked:

• Python version meets requirements
• Virtual environment is activated
• Required libraries are installed
• Network connectivity works

Professional developers write tests constantly. They don't trust that code works, they verify it. You're learning this mindset from the beginning.

After completing this chapter, you understand:

Professional developers succeed because they develop good habits early. Make these practices automatic:

• Always activate before working: Check for the (env-name) prefix before running any Python commands
• Install in activated environments: Never install packages without your virtual environment active
• Keep projects organized: All code goes in your api-projects folder for easy access and backup
• Search errors immediately: Don't struggle alone, every error has been encountered and solved before

These habits prevent the most common beginner mistakes. They're worth repeating until they become second nature.

Test your understanding of development environment setup and best practices before moving on:

These mistakes trip up every beginner. Being aware of them helps you avoid frustration:

This section contains solutions for the most common setup problems. Issues are numbered so earlier sections can reference them directly. Don't read this section linearly, use it as a reference when you encounter specific errors.

Error Message:

'python' is not recognized as an internal or external command

Or:

command not found: python

What This Means: Python isn't installed, or it's installed but not in your system's PATH (the list of locations your command line searches for programs).

Verify: python --version should now show Python 3.11+

macOS comes with Python 2 pre-installed, but you need Python 3. Two options:

Option A: Download from python.org (Recommended)

After installation, use python3 instead of python for all commands.

Option B: Install with Homebrew

If you have Homebrew installed:

brew install python3

Most Linux distributions include Python 3. If not:

sudo apt update
sudo apt install python3 python3-pip python3-venv

sudo dnf install python3 python3-pip

sudo pacman -S python python-pip

After installation, verify with python3 --version

Error Message:

'pip' is not recognized as an internal or external command

What This Means: pip isn't installed or isn't in your PATH. This is unusual since pip comes with Python 3.4+, but it happens.

On some systems, pip for Python 3 is called pip3:

pip3 --version

If this works, use pip3 instead of pip for all commands.

You can run pip as a Python module:

python -m pip --version

This almost always works. If it does, you can install packages with python -m pip install package-name

On some Linux distributions, pip needs to be installed separately:

sudo apt install python3-pip

Error Message:

No module named venv

What This Means: The venv module isn't installed. This typically happens on Linux where venv is a separate package.

sudo apt install python3-venv

sudo dnf install python3-virtualenv

Then try creating your virtual environment again:

python3 -m venv my-first-api-env

Error Message:

cannot be loaded because running scripts is disabled on this system

What This Means: Windows PowerShell's execution policy blocks script execution for security. You need to allow scripts to run.

Open PowerShell as Administrator (Right-click → Run as Administrator), then:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

Now try activating your virtual environment again in a regular (non-admin) command prompt.

Alternative: Use Command Prompt Instead

If you don't want to change PowerShell settings, use Command Prompt (cmd) instead. Virtual environment activation works without any policy changes in cmd.

Symptom: Running the activation command produces "file not found" or similar errors.

Cause: Either the virtual environment wasn't created successfully, or you're not in the right directory.

First, verify the environment folder exists:

ls my-first-api-env/bin/activate

If you get an error, the environment wasn't created. Delete it and start over:

rm -rf my-first-api-env
python3 -m venv my-first-api-env

Shell-Specific Activation (Advanced)

Different shells use different activation scripts:

my-first-api-env\Scripts\activate.bat

source my-first-api-env/bin/activate.csh

Error Message:

ERROR: Could not install packages due to an EnvironmentError: [Errno 13] Permission denied

What This Means: You're trying to install to system Python without administrator privileges, or you're not in an activated virtual environment.

This error usually means you're not in an activated virtual environment. Check for the (env-name) prefix. If it's missing:

# Windows
cd %USERPROFILE%\api-projects
my-first-api-env\Scripts\activate

# Mac/Linux
cd ~/api-projects
source my-first-api-env/bin/activate

Then install:

pip install requests

Error Message:

ModuleNotFoundError: No module named 'requests'

Most Common Cause: Mismatch between where requests is installed and which Python is running.

Step 1: Check which Python you're using:

which python  # Mac/Linux
where python   # Windows

Step 2: Check if requests is installed:

pip show requests

If "Location" doesn't match your virtual environment path, requests is installed elsewhere.

Make sure your virtual environment is active (look for the prefix), then:

pip install requests

Test again:

python

>>> import requests
>>> requests.__version__

Symptoms: Commands like cd, ls, or mkdir don't work, or you're confused about where you are in the file system.

Try this sequence to build comfort:

# See where you are
pwd  # or 'cd' on Windows

# Go to home directory
cd ~  # or 'cd %USERPROFILE%' on Windows

# List what's in this folder
ls  # or 'dir' on Windows

# Navigate into your api-projects folder
cd api-projects

# Confirm you're in the right place
pwd  # or 'cd' on Windows

If you get lost, cd ~ (or cd %USERPROFILE% on Windows) always takes you back to your home directory.

If you encounter an error not covered here, you're not alone, millions of developers have hit the same issue. Here's how to find solutions:

The setup process is complete. While it may have felt tedious at times, you've built a professional development environment that will serve you throughout this book and your entire programming career. The foundation you've laid here prevents countless hours of frustration later.

Test your understanding of development environment setup and best practices: