Aftab Ahmed's Blog

My 100-Day Python Journey - Day 10: Mastering Functions, Recursion, and a Calculator Project

Aftab Ahmed's photo
Aftab Ahmed
·

5 min read

Table of contents

Introduction

Greetings, fellow code enthusiasts! Day 10 of my 100-day Python adventure has been nothing short of exhilarating. Today, I've taken a deep dive into the world of functions, explored the intricacies of multiple return values, delved into docstrings, dissected the nuances between print and return, and ventured into the fascinating realm of flags and recursion. Stick around as I recount my challenges, discoveries, and cap it all off with a mini-project that beautifully showcases my evolving Python skills.

Functions with Outputs

Functions, the building blocks of any Python program, have become my trusty companions. Today's focus was on functions with outputs, made possible by the mighty return keyword. Let's start with a simple example that converts any string into title case:

def title_case(input_string):
    """
    This function takes an input string and returns it in title case.
    """
    return input_string.title()

result = title_case("hello, world!")
print(result)  # Output: "Hello, World!"

In this example, the title_case function accepts an input_string, applies the title() method to it, and returns the result in title case.

But wait, there's more! I've also concocted two additional functions: one to calculate the area of a rectangle and another to find the square of a number. These functions, too, make use of the return statement to deliver their results.

def calculate_rectangle_area(length, width):
    """
    This function calculates the area of a rectangle.
    """
    return length * width

def square(number):
    """
    This function computes the square of a number.
    """
    return number ** 2

Multiple Return Values

Python offers the fantastic ability to return multiple values from a single function. Think of it as receiving multiple gifts at once! Feast your eyes on this example:

def calculate_circle_properties(radius):
    """
    This function calculates both the circumference and area of a circle.
    """
    circumference = 2 * 3.14159 * radius
    area = 3.14159 * radius * radius
    return circumference, area

circle_circumference, circle_area = calculate_circle_properties(5)
print("Circumference:", circle_circumference)
print("Area:", circle_area)

In the calculate_circle_properties function, I'm returning both the circumference and area of a circle as a tuple. When calling the function, I unpack these values into separate variables for easy access.

Docstrings

In the world of programming, clear documentation is akin to a treasure map. Python supports docstrings, which are like instruction manuals for your functions. Here's how to add them:

def greet(name):
    """
    This function takes a name and returns a personalized greeting message.
    """
    return f"Hello, {name}!"

help(greet)  # This will display the docstring.

Docstrings provide vital information about a function's purpose, parameters, and usage, making your code more understandable and maintainable.

Print vs. Return

While both print and return can display information, they serve different purposes. Allow me to illustrate with these two code snippets:

def print_message(message):
    """
    This function prints the provided message.
    """
    print(message)

def return_message(message):
    """
    This function returns the provided message.
    """
    return message

print_message("Hello")  # This prints "Hello"
result = return_message("World")  # This assigns "World" to the variable result

print_message does exactly as its name suggests – it prints the message. In contrast, return_message returns the message, allowing you to store or manipulate the result.

Flags and Recursions

Flags are like traffic signals in programming; they help control the flow of your code. Recursion, on the other hand, is akin to a function calling itself, a concept that might seem mind-boggling but proves invaluable in solving complex problems by breaking them down into simpler subproblems. Let me showcase a classic example:

def factorial(n):
    """
    This recursive function calculates the factorial of a number.
    """
    if n == 1:
        return 1
    else:
        return n * factorial(n - 1)

In this factorial function, recursion works its magic. It repeatedly calls itself, each time with a smaller n, until it reaches the base case (n == 1) and then works its way back up, multiplying the results along the way. This recursive approach is both elegant and powerful.

Project: Crafting a Simple Calculator

As the cherry on top of Day 10, I undertook a mini-project – crafting a basic calculator.

The below Python code defines a simple calculator program that can perform basic arithmetic operations like addition, subtraction, multiplication, and division. It takes user input for numbers and the operation symbol, calculates the result, and offers the option to continue with the result or start a new calculation. The program uses functions, dictionaries, loops, and clear screen functionality.

from replit import clear
from art import logo

def add(n1, n2):
  return n1 + n2

def subtract(n1, n2):
  return n1 - n2

def multiply(n1, n2):
  return n1 * n2

def divide(n1, n2):
  return n1 / n2

operations = {
  "+": add,
  "-": subtract,
  "*": multiply,
  "/": divide
}

def calculator():
  print(logo)

  num1 = float(input("What's the first number?: "))
  for symbol in operations:
    print(symbol)
  should_continue = True

  while should_continue:
    operation_symbol = input("Pick an operation: ")
    num2 = float(input("What's the next number?: "))
    calculation_function = operations[operation_symbol]
    answer = calculation_function(num1, num2)
    print(f"{num1} {operation_symbol} {num2} = {answer}")

    if input(f"Type 'y' to continue calculating with {answer}, or type 'n' to start a new calculation: ") == 'y':
      num1 = answer
    else:
      should_continue = False
      clear()
      calculator()

calculator()

# I used replit to run the code

Conclusion

Day 10 has been a remarkable journey filled with insights into functions, docstrings, flags, and the enchanting world of recursion. I've not only expanded my Python repertoire but also culminated the day with a practical calculator project. Stay tuned for more exhilarating adventures on my 100-day Python journey as we continue to unravel the fascinating world of programming. Until next time, happy coding! 🚀

PythonProgramming Blogs100DaysOfCode