Scribd
Upload
7 views

A.A Programming Assignment Unit 4

Uploaded by

madandolataiwo
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
7 views

A.A Programming Assignment Unit 4

Uploaded by

madandolataiwo
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 5

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/

You might also like