Break down of the incremental development process for creating the hypotenuse function:
Stage 1: Basic Function Definition
- Define a function called `hypotenuse` that takes two arguments, `a` and `b`, representing the lengths of
the two legs of the right triangle.
- Return a placeholder value, such as `0`, for now.
```python
def hypotenuse(a, b):
return 0
```
Stage 2: Implementing the Pythagorean Theorem
- Calculate the length of the hypotenuse using the Pythagorean theorem: \( c = \sqrt{a^2 + b^2} \).
- Update the function to return the calculated hypotenuse.
```python
import math
def hypotenuse(a, b):
return math.sqrt(a ** 2 + b ** 2)
```
Stage 3: Testing with Sample Input
- Test the function with known values to verify correctness.
- Output the result for `hypotenuse(3, 4)`.
```python
import math
def hypotenuse(a, b):
return math.sqrt(a ** 2 + b ** 2)
print(hypotenuse(3, 4)) # Output: 5.0
```
Stage 4: Additional Testing
- Test the function with two more sets of different arguments.
- Output the results for these calls to `hypotenuse`.
```python
import math
def hypotenuse(a, b):
return math.sqrt(a ** 2 + b ** 2)
print(hypotenuse(3, 4)) # Output: 5.0
print(hypotenuse(5, 12)) # Output: 13.0
print(hypotenuse(8, 15)) # Output: 17.0
```
In this incremental development process, we started with a basic function definition and gradually added
functionality while testing each stage to ensure correctness. Finally, we tested the function with different
arguments to confirm its effectiveness.
Part 2: Developing Custom Function for Portfolio
As a software developer building a portfolio, I aim to create a custom function that demonstrates my
programming skills and problem-solving abilities. I will use an incremental development approach to
showcase my development process clearly.
Stage 1: Problem Understanding and Function Definition
- Define the problem statement and identify the task to be accomplished.
- Create a basic function skeleton with placeholder return values.
```python
Def custom_function(argument1, argument2):
“””
This function performs some useful computation using the given arguments.
“””
# Placeholder return value
Return 0
```
Stage 2: Implementing Basic Functionality
- Add the initial logic to the function to perform a simple computation.
- Test the function with known inputs to ensure it works as expected.
```python
Def custom_function(argument1, argument2):
“””
This function performs some useful computation using the given arguments.
“””
Result = argument1 + argument2
Return result
# Testing the function
Print(custom_function(3, 4)) # Output: 7
```
Stage 3: Enhancing Functionality
- Expand the functionality of the function to handle more complex computations or additional
arguments.
- Test the function with various inputs to verify its robustness.
```python
Def custom_function(argument1, argument2):
“””
This function performs some useful computation using the given arguments.
“””
Result = argument1 * argument2
Return result
# Testing the function with different inputs
Print(custom_function(3, 4)) # Output: 12
Print(custom_function(5, 12)) # Output: 60
Print(custom_function(8, 15)) # Output: 120
```
In this development process, I started by defining the problem and creating a basic function skeleton.
Then, I incrementally added functionality to the function while testing it with various inputs to ensure
correctness and robustness. Finally, I tested the function with different arguments to showcase its
versatility and usefulness. This incremental approach highlights my problem-solving skills and
programming proficiency, making it a valuable addition to my portfolio.
Reference
Downey, A. (2015). Think Python: How to think like a computer scientist. Needham, Massachusetts:
Green Tree Press. https://greenteapress.com/thinkpython2/thinkpython2.pdf
Python Program – Hypotenuse Using Pythagorean Theorem - https://www.instructables.com/Python-
Programming-Functions-Pythagorean-Theorem/
29 Python Portfolio Ideas to Showcase Your Skills – https://www.altcademy.com/blog/29-python-
portfolio-ideas-to-showcase-your-skills/
