Welcome, young wizard of code! Today, we're embarking on an enchanting journey through the mystical world of Python functions. Let's unlock the secrets and master the spells to control the Pythonic forces! 🧙‍♂️✨

The Magical Declaration: `def`

def greet():
    print("Hello, magical world!")

def: This is like the magic wand wave! It tells Python, "Hey, I'm creating a spell (function)!" 🪄
greet(): Here, we name our spell greet. The parentheses are like the magic circle, potentially holding special ingredients (parameters) needed for the spell, but this one is just an empty circle for now.
:: This colon is like saying, "Let the magic begin!" It opens up the block of code that defines what our spell does.

The Spell Body: Inside the Function

print("Hello, magical world!"): This is the incantation inside our spell. When activated, it sends out a message to the world. In non-magical terms, it prints a greeting to the screen. 🌍

Invoking the Spell

greet()

greet(): This is how you cast the spell! By calling the name of your function followed by parentheses, you activate the magic inside it, making the message appear.

Adding a Pinch of Personalization: Parameters

def greet(name):
    print(f"Hello, {name}, welcome to the magical world!")

name: Now we're adding a magical ingredient. name is a parameter, which means our spell can now be personalized. It's like adding a special herb or crystal to make the spell work for a specific person. 🌿✨

Personalized Spell Casting

greet("Mesbah")

"Mesbah": By providing a name here, we tailor our greeting. When this spell is cast, it will now say hello to Mesbah specifically, making the magic feel more special.

Multiple Ingredients: More Parameters

def magic_sum(a, b):
    return a + b

a, b: These are like two potent ingredients added to our cauldron. This spell, magic_sum, mixes them to create something new.
return a + b: The return keyword is the grand finale of the spell. It sends back the result of mixing a and b. In our mundane world, it calculates the sum of a and b.

The Result of the Concoction

result = magic_sum(7, 3)
print(result)

magic_sum(7, 3): Here we are casting our magic_sum spell with the numbers 7 and 3.
result: The magic does its work and gives us back 10, which we store in a variable called result.
print(result): Finally, revealing the outcome of our spell to the world. 🎉

By now, young wizard, you should feel a bit more comfortable with the enchanting world of Python functions. Use these spells wisely, and remember, with great power comes great responsibility! Happy coding! 🧙‍♂️💼📚

10 examples of Python functions

1. Greeting Function

def greet(name):
    print(f"Hello, {name}! How are you today?")

This function takes a name and prints a personalized greeting.

2. Adding Two Numbers

def add_numbers(x, y):
    return x + y

This function takes two numbers and returns their sum.

3. Checking Even Numbers

def is_even(number):
    return number % 2 == 0

This function checks if a number is even and returns True or False.

4. Calculate Factorial

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

This function calculates the factorial of a number using recursion.

5. Concatenate Strings

def concatenate_strings(a, b):
    return a + " " + b

This function takes two strings, concatenates them with a space in between, and returns the result.

6. Find Maximum of Three Numbers

def max_of_three(x, y, z):
    return max(x, y, z)

This function returns the maximum of three numbers.

7. Convert Celsius to Fahrenheit

def celsius_to_fahrenheit(celsius):
    return (celsius * 9/5) + 32

This function converts a temperature from Celsius to Fahrenheit.

8. Reverse a String

def reverse_string(s):
    return s[::-1]

This function returns the reverse of the input string.

9. Calculate the Length of a List

def list_length(lst):
    count = 0
    for _ in lst:
        count += 1
    return count

This function counts and returns the number of items in a list.

10. Check Prime Number

def is_prime(num):
    if num <= 1:
        return False
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            return False
    return True

This function checks if a number is prime by testing divisibility.

The Magical Declaration: def