Skip to main content

Functions ✨

Functions are the rockstars of programming—they take the stage, perform their job, and vanish into the shadows, leaving the code cleaner, smarter, and more organised. Think of them as mini-programs within your program, capable of taking inputs, doing some mysterious calculations, and returning the grand result. Oh, and the best part? You can summon them as many times as you want! Let’s explore the magic of functions with some examples. 🎩🐇

What’s a Function, Anyway?​

A function is like a chef in a kitchen. You give the chef some ingredients (inputs), they whip up something delicious (process), and then present you with a tasty dish (output). You don’t care how they made it—you just enjoy the result. Similarly, a function takes inputs (parameters), does something cool inside, and returns a result.

How to Declare a Function​

Pseudo-Code Syntax​

FUNCTION FunctionName(Parameter1 : DataType, Parameter2 : DataType) RETURNS DataType
    // Do something cool
    RETURN Result
ENDFUNCTION

Python Syntax​

def function_name(parameter1, parameter2):
    # Do something cool
    return result

Examples: Unleashing the Power of Functions​

Example 1: The Classic Square Calculator 🟥​

Pseudo-Code:

FUNCTION Square(Number : INTEGER) RETURNS INTEGER
    RETURN Number * Number
ENDFUNCTION

Result ← Square(4)
OUTPUT Result

Python:

def Square(Number):
    return Number * Number

Result = Square(4)
print(Result)

Output:

16

"Square your life, square your troubles, but don’t square your crush—it’s creepy." 🥴

Example 2: Temperature Conversion 🌡️​

Pseudo-Code:

FUNCTION CelsiusToFahrenheit(Celsius : REAL) RETURNS REAL
    RETURN (Celsius * 9 / 5) + 32
ENDFUNCTION

TemperatureInF ← CelsiusToFahrenheit(25)
OUTPUT TemperatureInF

Python:

def CelsiusToFahrenheit(Celsius):
    return (Celsius * 9 / 5) + 32

TemperatureInF = CelsiusToFahrenheit(25)
print(TemperatureInF)

Output:

77.0

"When it’s 77°F outside, remember it started as 25°C. Global warming works both ways!" 🌍

Example 3: The Factorial Phenomenon! 😱​

Pseudo-Code:

FUNCTION Factorial(Number : INTEGER) RETURNS INTEGER
    IF Number = 1 THEN
        RETURN 1
    ELSE
        RETURN Number * Factorial(Number - 1)
    ENDIF
ENDFUNCTION

Result ← Factorial(5)
OUTPUT Result

Python:

def Factorial(Number):
    if Number == 1:
        return 1
    else:
        return Number * Factorial(Number - 1)

Result = Factorial(5)
print(Result)

Output:

120

"Factorials are like onions. They have layers, and they might make you cry." 🧅

Example 4: Nested Functions—Like Inception, But Code! 🎥​

Pseudo-Code:

FUNCTION OuterFunction(Number : INTEGER) RETURNS INTEGER
    FUNCTION InnerFunction(Value : INTEGER) RETURNS INTEGER
        RETURN Value * 2
    ENDFUNCTION

    RETURN InnerFunction(Number) + 5
ENDFUNCTION

Result ← OuterFunction(3)
OUTPUT Result

Python:

def OuterFunction(Number):
    def InnerFunction(Value):
        return Value * 2

    return InnerFunction(Number) + 5

Result = OuterFunction(3)
print(Result)

Output:

11

"It’s like a function within a function… function-ception!" 🌀

Example 5: Find the Best Pizza Topping 🍕​

Pseudo-Code:

FUNCTION BestTopping(Topping : STRING) RETURNS STRING
    IF Topping = "Pepperoni" THEN
        RETURN "Excellent choice!"
    ELSE
        RETURN "Try Pepperoni next time."
    ENDIF
ENDFUNCTION

Response ← BestTopping("Mushrooms")
OUTPUT Response

Python:

def BestTopping(Topping):
    if Topping == "Pepperoni":
        return "Excellent choice!"
    else:
        return "Try Pepperoni next time."

Response = BestTopping("Mushrooms")
print(Response)

Output:

Try Pepperoni next time.

"Mushrooms? Really? We’re judging, but only a little." 🍄

Example 6: Who’s the Boss? 🤵👩‍💼​

Pseudo-Code:

FUNCTION WhoIsTheBoss(Name : STRING) RETURNS STRING
    RETURN Name + " is the boss!"
ENDFUNCTION

Response ← WhoIsTheBoss("Alice")
OUTPUT Response

Python:

def WhoIsTheBoss(Name):
    return Name + " is the boss!"

Response = WhoIsTheBoss("Alice")
print(Response)

Output:

Alice is the boss!

"Bow down, peasants. The boss has entered!" 👑

Example 7: The Double Trouble Function 🤔​

Pseudo-Code:

FUNCTION DoubleIt(Value : INTEGER) RETURNS INTEGER
    RETURN Value * 2
ENDFUNCTION

FUNCTION TripleIt(Value : INTEGER) RETURNS INTEGER
    RETURN Value * 3
ENDFUNCTION

DoubleResult ← DoubleIt(4)
TripleResult ← TripleIt(3)
OUTPUT DoubleResult, TripleResult

Python:

def DoubleIt(Value):
    return Value * 2

def TripleIt(Value):
    return Value * 3

DoubleResult = DoubleIt(4)
TripleResult = TripleIt(3)
print(DoubleResult, TripleResult)

Output:

8 9

"Double it, triple it, but don’t quadruple it unless you’re ready for chaos." 🤯

Final Thoughts on Functions​

Functions are the multitasking superheroes of programming. Whether you’re calculating pizza toppings, factorials, or nested nightmares, they make life simpler, cleaner, and more fun. With great power comes great responsibility, so use your functions wisely! 😉