Step 1: Setting Up the Development Environment
Before writing any code, it’s important to ensure that your development environment is configured properly. In this example, we’ll be working with Python, so make sure you have Python installed on your system (version 3.6 or later works well). You can download it from the official Python website.
You might also want to set up a virtual environment to keep project dependencies isolated. Here’s how you can do that:
# Create a virtual environment in the 'env' directory
python -m venv env
# Activate the virtual environment (Linux/Mac)
source env/bin/activate
# Or activate on Windows
env\Scripts\activate
# Optionally install any initial packages (for example, requests)
pip install requests
Explanation:
• The above commands create and activate a virtual environment named “env”.
• Once activated, all Python packages you install will be isolated to this environment.
• Installing common packages (like requests) sets up your project with tools you might need later.
Step 2: Creating a Basic Python Script
Now that the environment is ready, let’s create a simple Python script that prints “Hello, World!”. This script is a traditional way to validate that your setup is working correctly.
Create a file named main.py and add the following code:
# main.py
def main():
"""
The main function that prints a greeting message.
"""
greeting = "Hello, World!"
print(greeting)
if __name__ == "__main__":
main()
Explanation:
• We define a function called main() which holds our primary program logic.
• The variable greeting stores the string we want to display.
• The conditional if __name__ == "__main__": ensures that main() is only executed when the script is run directly, not when imported as a module.
• Running python main.py in your terminal should output:
Hello, World!
Step 3: Implementing a Core Feature (A Simple Calculator)
Let’s extend the functionality by adding a simple calculator that can perform basic arithmetic operations. This example demonstrates how to write functions, capture user input, and handle errors.
Modify your main.py to include the calculator functionality:
# main.py
def add(a, b):
"""Return the sum of two numbers."""
return a + b
def subtract(a, b):
"""Return the difference between two numbers."""
return a - b
def multiply(a, b):
"""Return the product of two numbers."""
return a * b
def divide(a, b):
"""Return the division of a by b, handling division by zero."""
if b == 0:
raise ValueError("Cannot divide by zero!")
return a / b
def simple_calculator():
"""
A simple calculator that performs an arithmetic operation
based on user input.
"""
print("Simple Calculator")
print("Select operation:")
print("1. Add")
print("2. Subtract")
print("3. Multiply")
print("4. Divide")
operation = input("Enter choice (1/2/3/4): ")
try:
num1 = float(input("Enter first number: "))
num2 = float(input("Enter second number: "))
except ValueError:
print("Invalid number entered. Please try again.")
return
try:
if operation == "1":
result = add(num1, num2)
elif operation == "2":
result = subtract(num1, num2)
elif operation == "3":
result = multiply(num1, num2)
elif operation == "4":
result = divide(num1, num2)
else:
print("Invalid operation selected!")
return
print("Result:", result)
except ValueError as error:
print("Error:", error)
def main():
"""
Main function that offers a choice between a greeting
and running the calculator.
"""
print("Welcome to the Python Demo Program!")
print("1. Print Hello, World!")
print("2. Launch Simple Calculator")
choice = input("Enter option (1/2): ")
if choice == "1":
print("Hello, World!")
elif choice == "2":
simple_calculator()
else:
print("Invalid choice. Exiting program.")
if __name__ == "__main__":
main()
Explanation:
• We define separate functions for addition, subtraction, multiplication, and division.
• The divide function includes error handling for division by zero.
• In simple_calculator(), we display a menu, capture user inputs for operation and operands, and then call the appropriate arithmetic function.
• All user inputs are typecast to float to support decimal operations, and a try–except block handles possible conversion errors.
• Finally, the main() function acts as a menu to either print a greeting or launch the calculator.
Step 4: Implementing Unit Tests
To ensure our calculator functions work as expected, we can write unit tests. Python’s built-in unittest framework is perfect for this.
Create a new file test_calculator.py and add the following tests:
# test_calculator.py
import unittest
from main import add, subtract, multiply, divide
class TestCalculator(unittest.TestCase):
def test_add(self):
self.assertEqual(add(1, 2), 3)
self.assertEqual(add(-1, 1), 0)
def test_subtract(self):
self.assertEqual(subtract(5, 3), 2)
self.assertEqual(subtract(0, 5), -5)
def test_multiply(self):
self.assertEqual(multiply(4, 3), 12)
self.assertEqual(multiply(-2, 3), -6)
def test_divide(self):
self.assertEqual(divide(10, 2), 5)
with self.assertRaises(ValueError):
divide(10, 0)
if __name__ == "__main__":
unittest.main()
Explanation:
• The unittest module is imported and a test case class TestCalculator is defined.
• For each arithmetic function, we create test methods that check for correct output as well as the correct handling of edge cases (e.g., division by zero).
• The with self.assertRaises(ValueError): block verifies that the divide function raises an exception when dividing by zero.
• Run these tests via the command line by executing:
python test_calculator.py
This will run each test and display the results.
Each of these steps builds upon the previous ones, helping you understand not only how to structure your code but also how to test it effectively. By following these steps, you can gradually build out more complex projects while ensuring your code remains clean, maintainable, and robust.