Introduction to Python Programming

Introduction: The Power of Reusability

As your Python programs become more complex, you'll find yourself writing the same or very similar blocks of code multiple times. This leads to code that's hard to read, difficult to maintain, and prone to errors. Imagine a scenario where you need to calculate an employee's bonus in several different parts of your application – if the calculation logic changes, you'd have to update it in every single place!

This is where functions come in. A function is a block of organized, reusable code that is used to perform a single, related action. Think of functions as mini-programs within your main program, designed to accomplish specific tasks.

Functions are fundamental to writing clean, modular, and efficient code. They embody the "Don't Repeat Yourself" (DRY) principle. UdaanPath strongly emphasizes modular programming, and understanding functions is your next critical step towards becoming a skilled Python developer.

Core Concepts: Defining and Using Functions

def greet(): # No parameters
    """
    This function simply prints a greeting message.
    """
    print("Hello from UdaanPath!")
    print("Welcome to Python programming.")

# An empty function (useful as a placeholder)
def coming_soon_feature():
    pass # 'pass' is a placeholder that does nothing
                    

def calculate_square(number):
    """
    Calculates the square of a given number.

    Args:
        number (int or float): The number to be squared.

    Returns:
        int or float: The square of the number.
    """
    return number * number

print(f"Docstring for calculate_square:\n{calculate_square.__doc__}")
                    

Docstring for calculate_square:
    Calculates the square of a given number.

    Args:
        number (int or float): The number to be squared.

    Returns:
        int or float: The square of the number.

# Call the greet function
greet() # No arguments needed

# Call the coming_soon_feature (it does nothing)
coming_soon_feature()
                    

Hello from UdaanPath!
Welcome to Python programming.

def display_udaan_course(course_name, instructor):
    print(f"Course: {course_name}")
    print(f"Instructor: {instructor}")

display_udaan_course("Data Science Mastery", "Ms. Priya Singh")
display_udaan_course("Web Development Bootcamp", "Mr. Rahul Kumar")
                    

Course: Data Science Mastery
Instructor: Ms. Priya Singh
Course: Web Development Bootcamp
Instructor: Mr. Rahul Kumar

def create_profile(name, email, age):
    print(f"Creating profile for: {name}")
    print(f"Email: {email}, Age: {age}")

# Using keyword arguments
create_profile(email="john@example.com", name="John Doe", age=28)
                    

Creating profile for: John Doe
Email: john@example.com, Age: 28

def send_notification(message, recipient="Admin", priority="low"):
    print(f"Sending '{message}' to {recipient} with {priority} priority.")

send_notification("System update complete.") # Uses default recipient and priority
send_notification("Urgent bug fix needed!", "Developer Team", "high") # Override defaults
send_notification(recipient="User Support", message="Query resolved.") # Mix positional and keyword
                    

Sending 'System update complete.' to Admin with low priority.
Sending 'Urgent bug fix needed!' to Developer Team with high priority.
Sending 'Query resolved.' to User Support with low priority.

def add_numbers(a, b):
    """Adds two numbers and returns the sum."""
    return a + b

def get_udaan_user_status(user_id):
    """
    Simulates fetching user status for a given ID.
    Returns name and status.
    """
    if user_id == 101:
        return "Prashant", "Active"
    elif user_id == 102:
        return "Divya", "Inactive"
    else:
        return "Unknown", "N/A"

result = add_numbers(15, 7)
print(f"Sum of 15 and 7: {result}")

user_name, user_status = get_udaan_user_status(101) # Unpacking multiple return values
print(f"User 101: Name - {user_name}, Status - {user_status}")

unknown_user_name, unknown_user_status = get_udaan_user_status(999)
print(f"User 999: Name - {unknown_user_name}, Status - {unknown_user_status}")

# What if a function has no explicit return?
def do_nothing_special():
    print("Just printing.")

none_return = do_nothing_special()
print(f"Return value of do_nothing_special: {none_return}")
                    

Sum of 15 and 7: 22
User 101: Name - Prashant, Status - Active
User 999: Name - Unknown, Status - N/A
Just printing.
Return value of do_nothing_special: None

global_message = "This is a global message from UdaanPath!"

def my_function():
    local_variable = "I am a local variable."
    print(f"Inside function: {local_variable}")
    print(f"Inside function (accessing global): {global_message}")

def modify_global_variable():
    # Attempting to reassign a global variable without 'global' keyword
    # will create a NEW local variable with the same name.
    # To actually modify the global variable, you need 'global global_message'
    # For now, let's just observe.
    global_message = "This is a NEW local message in modify_global_variable"
    print(f"Inside modify_global_variable: {global_message}")

print(f"Outside function (initial global): {global_message}")
my_function()
# print(local_variable) # This would cause a NameError!

modify_global_variable()
print(f"Outside function (after modify_global_variable call): {global_message}") # Global is unchanged!

# Correct way to modify a global variable (use with caution!)
def truly_modify_global():
    global global_message
    global_message = "Global message has been truly modified!"
    print(f"Inside truly_modify_global: {global_message}")

truly_modify_global()
print(f"Outside function (after truly_modify_global call): {global_message}")
                    

Outside function (initial global): This is a global message from UdaanPath!
Inside function: I am a local variable.
Inside function (accessing global): This is a global message from UdaanPath!
Inside modify_global_variable: This is a NEW local message in modify_global_variable
Outside function (after modify_global_variable call): This is a global message from UdaanPath!
Inside truly_modify_global: Global message has been truly modified!
Outside function (after truly_modify_global call): Global message has been truly modified!

Key Takeaways & Best Practices

• DRY Principle: Functions are your primary tool to avoid repeating code. If you find yourself copying and pasting code, it's a strong sign it needs to be a function.
• Single Responsibility: Ideally, a function should do one thing and do it well. This makes functions easier to test, debug, and reuse.
• Meaningful Names: Give your functions clear, descriptive names that indicate their purpose (e.g., `calculate_area`, `get_user_data`, `process_payment`).
• Docstrings are Gold: Always write docstrings for your functions. They are invaluable for documentation and understanding code quickly.
• Return vs. Print: Understand the difference. `print()` displays output to the console. `return` sends a value back from the function to be used elsewhere in your program.
• Manage Scope: Be mindful of variable scope. Prefer passing arguments and returning values over directly modifying global variables, which can lead to hard-to-find bugs.

Interview Tip: Functions are a cornerstone of programming. Expect questions on defining, calling, parameters vs. arguments, return values, and variable scope.

Mini-Challenge: UdaanPath Enrollment Calculator!

Let's create a function to help calculate enrollment fees for UdaanPath courses. Create a Python script named `enrollment_calculator.py`.

• Define a function called `calculate_enrollment_fee` that takes two parameters:
  - `base_fee` (float or int): The standard fee for the course.
  - `discount_percentage` (float, optional, default is `0.0`): The percentage discount to apply.
• Inside the function, calculate the final fee: `final_fee = base_fee - (base_fee * discount_percentage / 100)`.
• The function should return the `final_fee`.
• Add a good docstring to your function.
• Call the function to calculate the fee for a course with a `base_fee` of `5000` and no discount. Print the result.
• Call the function to calculate the fee for a course with a `base_fee` of `7500` and a `discount_percentage` of `10`. Print the result.
• Call the function using keyword arguments for a `base_fee` of `10000` and `discount_percentage` of `5`. Print the result.

Run your `enrollment_calculator.py` script and see your reusable function in action!

# def calculate_enrollment_fee(base_fee, discount_percentage=0.0):
#    """
#    Your docstring here.
#    """
#    # Your calculation and return here

# Call the function multiple times and print results
# result1 = calculate_enrollment_fee(...)
# print(f"...")
                

$ python enrollment_calculator.py
Fee for standard course: 5000.0
Fee for discounted course (10%): 6750.0
Fee for premium course (5% discount): 9500.0