Python Project Essentials

Developing a Python application involves much more than writing code. Modern Python projects require proper project organization, dependency management, configuration handling, and communication with external services. In this module, you’ll learn the essential tools and practices used in professional Python development.

Topics Covered

In this module, you’ll learn:

Project Structure
Virtual Environments
Dependency Management with uv
Environment Variables and Configuration
Working with JSON Data
Consuming REST APIs
Dependency Injection Concepts
Best Practices

Try Yourself: 💻 VS Code | 🚀 Colab | 📥 Download
Verify Solutions: 💻 VS Code | 🚀 Colab | 📥 Download

By the end of this module, you’ll be able to organize Python projects, manage dependencies efficiently, configure applications securely, exchange JSON data, consume REST APIs, and understand the fundamentals of dependency injection.

Project Structure

A well-organized project is easier to understand, maintain, and extend. A typical Python project might look like this.

student-management/

├── .venv/
├── .env
├── pyproject.toml
├── main.py
├── README.md
├── app/
│   ├── __init__.py
│   ├── models.py
│   ├── services.py
│   └── utils.py
└── data/

Common Files

File	Purpose
`pyproject.toml`	Project configuration and dependencies
`.venv`	Virtual environment
`.env`	Environment variables
`README.md`	Project documentation
`main.py`	Application entry point

As your project grows, organizing code into separate modules and packages improves readability and maintainability.

Exercise 1

Create the following project structure. Expected Structure

library-system/

├── app/
├── data/
├── .venv/
├── .env
├── pyproject.toml
└── main.py

Solution

Create the folders and files using your preferred editor or the terminal.

Exercise 2

Identify the purpose of each file.

File	Purpose
`.env`	?
`.venv`	?
`pyproject.toml`	?
`README.md`	?

Solution

File	Purpose
`.env`	Stores configuration values and secrets
`.venv`	Isolated Python environment
`pyproject.toml`	Project metadata and dependencies
`README.md`	Project documentation

Virtual Environments

A virtual environment is an isolated Python environment for a project. It allows each project to have its own:

Python packages
Package versions
Dependencies

Without virtual environments, installing a package for one project affects every project on your system.

Creating a Virtual Environment

Using the built-in venv module.

python -m venv .venv

Activate it. Windows

.venv\Scripts\activate

macOS / Linux

source .venv/bin/activate

Deactivate the environment.

deactivate

Why Use Virtual Environments?

Prevent dependency conflicts.
Keep projects isolated.
Make projects reproducible.
Simplify dependency management.

Exercise 1

Create and activate a virtual environment for a new project.

Solution

python -m venv .venv

source .venv/bin/activate

(macOS/Linux)or

.venv\Scripts\activate

(Windows)

Exercise 2

Deactivate the virtual environment. Expected Command

deactivate

Dependency Management with `uv`

uv is a modern Python package and project manager. It is significantly faster than traditional tools such as pip because it is implemented in Rust.

Installing `uv`

pip install uv

Verify the installation.

uv --version

Creating a Project

uv init student-management

This creates a new project with a standard structure.

Adding a Package

uv add requests

The dependency is automatically added to the project configuration.

Installing Dependencies

uv sync

This installs all dependencies listed in pyproject.toml.

Removing a Package

uv remove requests

Running Python

uv run main.py

Why Use `uv`?

Fast dependency resolution.
Modern project management.
Automatic virtual environment creation.
Reproducible builds.
Simple dependency synchronization.

Exercise 1

Create a new project named student-management using uv. Expected Command

uv init student-management

Exercise 2

Add the requests package and synchronize the project. Expected Commands

uv add requests

uv sync

Environment Variables

Environment variables allow you to store configuration values outside your source code. They are commonly used to store:

API Keys
Database URLs
Secret Keys
Application Settings

Instead of writing sensitive information directly in your code,

API_KEY = "my-secret-key"

store it in a .env file.

API_KEY=my-secret-key
DATABASE_URL=sqlite:///students.db
DEBUG=True

This keeps sensitive information separate from your application.

Reading Environment Variables

Install the package.

uv add python-dotenv

Create a .env file.

API_KEY=my-secret-key

Read the value.

from dotenv import load_dotenv
import os

load_dotenv()

api_key = os.getenv("API_KEY")

print(api_key)

Output ?

Show Output

my-secret-key

Providing Default Values

Use a default value when an environment variable is missing.

import os

host = os.getenv("HOST", "localhost")

print(host)

Output ?

Show Output

localhost

Why Use Environment Variables?

Keep secrets out of source code.
Use different configurations for development and production.
Improve application security.
Simplify deployment.

Exercise 1

Create a .env file containing:

APP_NAME
PORT

Read and display both values. Expected Output

Student Management System
8000

Solution

APP_NAME=Student Management System
PORT=8000

from dotenv import load_dotenv
import os

load_dotenv()

print(os.getenv("APP_NAME"))
print(os.getenv("PORT"))

Exercise 2

Read an environment variable named HOST. If it doesn’t exist, display "localhost". Expected Output

localhost

Solution

import os

host = os.getenv("HOST", "localhost")

print(host)

Configuration Management

As projects grow, configuration values increase. Instead of scattering configuration throughout the application, place them in one location. Example project.

project/

├── .env
├── config.py
└── main.py

config.py

from dotenv import load_dotenv
import os

load_dotenv()

APP_NAME = os.getenv("APP_NAME")
DATABASE_URL = os.getenv("DATABASE_URL")
DEBUG = os.getenv("DEBUG")

main.py

import config

print(config.APP_NAME)
print(config.DATABASE_URL)

This approach centralizes application configuration and makes maintenance easier.

Best Practices

Never hardcode secrets.
Use .env for local development.
Keep configuration in one module.
Add .env to .gitignore.

Exercise 1

Create a config.py file that loads:

APP_NAME
DEBUG

Solution

from dotenv import load_dotenv
import os

load_dotenv()

APP_NAME = os.getenv("APP_NAME")
DEBUG = os.getenv("DEBUG")

Exercise 2

Use config.py in another Python file to display the application name.

Solution

import config

print(config.APP_NAME)

Working with JSON Data

JSON (JavaScript Object Notation) is the most widely used format for exchanging data between applications. A JSON document consists of key-value pairs. Example JSON.

{
    "name": "Alice",
    "age": 20,
    "course": "Python"
}

Python provides the built-in json module for working with JSON.

import json

Converting Python Objects to JSON

Use json.dumps().

import json

student = {
    "name": "Alice",
    "age": 20,
    "course": "Python"
}

json_data = json.dumps(student, indent=4)

print(json_data)

Output ?

Show Output

{
    "name": "Alice",
    "age": 20,
    "course": "Python"
}

Converting JSON to Python Objects

Use json.loads().

import json

data = '''
{
    "name": "Alice",
    "age": 20
}
'''

student = json.loads(data)

print(student["name"])
print(student["age"])

Output ?

Show Output

Alice
20

Reading JSON from a File

Suppose student.json contains

{
    "name": "Alice",
    "course": "Python"
}

Read the file.

import json

with open("student.json") as file:
    student = json.load(file)

print(student)

Output ?

Show Output

{'name': 'Alice', 'course': 'Python'}

Writing JSON to a File

import json

student = {
    "name": "Alice",
    "course": "Python"
}

with open("student.json", "w") as file:
    json.dump(student, file, indent=4)

This creates a formatted JSON file.

Exercise 1

Convert the following dictionary into JSON.

employee = {
    "name": "Rahul",
    "department": "IT"
}

Solution

import json

employee = {
    "name": "Rahul",
    "department": "IT"
}

print(json.dumps(employee, indent=4))

Exercise 2

Read the following JSON string and display the employee name.

{
    "name": "Rahul",
    "salary": 50000
}

Expected Output

Rahul

Solution

import json

data = '''
{
    "name": "Rahul",
    "salary": 50000
}
'''

employee = json.loads(data)

print(employee["name"])

Consuming REST APIs

Modern applications frequently communicate with external services using REST APIs. Some common examples include:

Weather applications
Payment gateways
AI services
Maps and location services
Social media platforms

Python provides several libraries for consuming REST APIs. One of the most popular is requests. Install it using uv.

uv add requests

Making a GET Request

Let’s fetch sample user information from the JSONPlaceholder API.

import requests

url = "https://jsonplaceholder.typicode.com/users/1"

response = requests.get(url)

print(response.status_code)

Output ?

Show Output

A status code of 200 indicates that the request was successful.

Reading JSON Response

Most REST APIs return JSON.

import requests

url = "https://jsonplaceholder.typicode.com/users/1"

response = requests.get(url)

user = response.json()

print(user["name"])
print(user["email"])

Output ?

Show Output

Leanne Graham
[email protected]

Sending Query Parameters

Query parameters provide additional information to the server.

import requests

url = "https://jsonplaceholder.typicode.com/comments"

params = {
    "postId": 1
}

response = requests.get(
    url,
    params=params
)

print(response.status_code)

Output ?

Show Output

The generated URL becomes

https://jsonplaceholder.typicode.com/comments?postId=1

Sending Headers

Headers provide additional metadata such as API keys.

headers = {
    "Authorization": "Bearer YOUR_API_KEY"
}

response = requests.get(
    url,
    headers=headers
)

Many real-world APIs require authentication through headers.

Making a POST Request

import requests

url = "https://jsonplaceholder.typicode.com/posts"

data = {
    "title": "Python",
    "body": "Learning REST APIs",
    "userId": 1
}

response = requests.post(
    url,
    json=data
)

print(response.status_code)

Output ?

Show Output

Status code 201 indicates that a new resource was created.

Common HTTP Methods

Method	Purpose
GET	Retrieve data
POST	Create data
PUT	Update an entire resource
PATCH	Update part of a resource
DELETE	Remove a resource

Exercise 1

Fetch user 5 from JSONPlaceholder and display the user’s name. Expected Output

Chelsey Dietrich

Solution

import requests

response = requests.get(
    "https://jsonplaceholder.typicode.com/users/5"
)

user = response.json()

print(user["name"])

Exercise 2

Create a new post using the JSONPlaceholder API. Expected Output

Solution

import requests

response = requests.post(
    "https://jsonplaceholder.typicode.com/posts",
    json={
        "title": "Python",
        "body": "Learning APIs",
        "userId": 1
    }
)

print(response.status_code)

Dependency Injection Concepts

As applications grow, classes often depend on other classes. For example, an application may have:

Database Service
Email Service
Notification Service
Authentication Service

If one class creates its own dependencies, the code becomes tightly coupled.

Without Dependency Injection

class EmailService:

    def send(self):
        print("Email Sent")

class NotificationService:

    def __init__(self):
        self.email = EmailService()

    def notify(self):
        self.email.send()

notification = NotificationService()

notification.notify()

Output ?

Show Output

Email Sent

Here, NotificationService directly creates an EmailService. Replacing the email service later becomes difficult.

With Dependency Injection

Instead of creating the dependency inside the class, pass it from outside.

class EmailService:

    def send(self):
        print("Email Sent")

class NotificationService:

    def __init__(self, service):
        self.service = service

    def notify(self):
        self.service.send()

email = EmailService()

notification = NotificationService(email)

notification.notify()

Output ?

Show Output

Email Sent

The dependency is now injected from outside. This makes the code:

Easier to test
Easier to maintain
More reusable
Less tightly coupled

Another Example

class SMSService:

    def send(self):
        print("SMS Sent")

sms = SMSService()

notification = NotificationService(sms)

notification.notify()

Output ?

Show Output

SMS Sent

Notice that NotificationService did not change. Only the dependency changed. This is the primary advantage of Dependency Injection.

Exercise 1

Create a PaymentService class and inject it into an OrderService. Expected Output

Payment Successful

Solution

class PaymentService:

    def pay(self):
        print("Payment Successful")

class OrderService:

    def __init__(self, payment):
        self.payment = payment

    def checkout(self):
        self.payment.pay()

payment = PaymentService()

order = OrderService(payment)

order.checkout()

Exercise 2

Create both EmailService and SMSService and inject each into NotificationService. Expected Output

Email Sent
SMS Sent

Solution

class EmailService:

    def send(self):
        print("Email Sent")


class SMSService:

    def send(self):
        print("SMS Sent")


class NotificationService:

    def __init__(self, service):
        self.service = service

    def notify(self):
        self.service.send()


NotificationService(
    EmailService()
).notify()

NotificationService(
    SMSService()
).notify()

Best Practices

Organize projects into logical modules and packages.
Use virtual environments for every project.
Manage dependencies with uv.
Store secrets in environment variables.
Keep configuration separate from source code.
Use JSON for data exchange.
Handle API responses and errors gracefully.
Prefer dependency injection over creating dependencies inside classes.

Practice

To reinforce what you’ve learned in this section, practice with the interactive follow-along notebook:

Follow-Along Practice

Practice dependency management using uv, reading environment variables from .env, parsing/generating JSON payloads, calling REST APIs using requests, and implementing dependency injection.💻 VS Code | 🚀 Colab | 📥 Download

Summary

In this module, you learned the essential tools and practices used in modern Python projects.

Key Concepts Covered

Project Structure
Virtual Environments
Dependency Management with uv
Environment Variables
Configuration Management
Working with JSON
Consuming REST APIs
Dependency Injection Concepts
Best Practices

These concepts form the foundation of professional Python development and are widely used in frameworks such as FastAPI, Django, and Flask.

​Python Project Essentials

​Topics Covered

​Project Structure

​Common Files

​Exercise 1

​Exercise 2

​Virtual Environments

​Creating a Virtual Environment

​Why Use Virtual Environments?

​Exercise 1

​Exercise 2

​Dependency Management with uv

​Installing uv

​Creating a Project

​Adding a Package

​Installing Dependencies

​Removing a Package

​Running Python

​Why Use uv?

​Exercise 1

​Exercise 2

​Environment Variables

​Reading Environment Variables

​Providing Default Values

​Why Use Environment Variables?

​Exercise 1

​Exercise 2

​Configuration Management

​Best Practices

​Exercise 1

​Exercise 2

​Working with JSON Data

​Converting Python Objects to JSON

​Converting JSON to Python Objects

​Reading JSON from a File

​Writing JSON to a File

​Exercise 1

​Exercise 2

​Consuming REST APIs

​Making a GET Request

​Reading JSON Response

​Sending Query Parameters

​Sending Headers

​Making a POST Request

​Common HTTP Methods

​Exercise 1

​Exercise 2

​Dependency Injection Concepts

​Without Dependency Injection

​With Dependency Injection

​Another Example

​Exercise 1

​Exercise 2

​Best Practices

​Practice

Follow-Along Practice

​Summary

​Key Concepts Covered

Python Project Essentials

Topics Covered

Project Structure

Common Files

Exercise 1

Exercise 2

Virtual Environments

Creating a Virtual Environment

Why Use Virtual Environments?

Exercise 1

Exercise 2

Dependency Management with `uv`

Installing `uv`

Creating a Project

Adding a Package

Installing Dependencies

Removing a Package

Running Python

Why Use `uv`?

Exercise 1

Exercise 2

Environment Variables

Reading Environment Variables

Providing Default Values

Why Use Environment Variables?

Exercise 1

Exercise 2

Configuration Management

Best Practices

Exercise 1

Exercise 2

Working with JSON Data

Converting Python Objects to JSON

Converting JSON to Python Objects

Reading JSON from a File

Writing JSON to a File

Exercise 1

Exercise 2

Consuming REST APIs

Making a GET Request

Reading JSON Response

Sending Query Parameters

Sending Headers

Making a POST Request

Common HTTP Methods

Exercise 1

Exercise 2

Dependency Injection Concepts

Without Dependency Injection

With Dependency Injection

Another Example

Exercise 1

Exercise 2

Best Practices

Practice

Summary

Key Concepts Covered