Skip to content

python-functions.md

Latest commit

 

History

History
464 lines (334 loc) · 9.92 KB

python-functions.md

File metadata and controls

464 lines (334 loc) · 9.92 KB
id python-functions
title Functions in Python
sidebar_label Functions in Python
sidebar_position 11
tags
Python
Functions
def
return
arguments
parameters
args
kwargs
Python Syntax
Introduction of python

Functions in Python

A function in Python is a block of reusable code that performs a specific task. Functions help organize code, avoid repetition, and make programs more modular and maintainable.

Functions are defined using the def keyword and can accept inputs (parameters) and return outputs.

Defining a Function

Use the def keyword followed by the function name and parentheses:

def greet():
    print("Hello, World!")

# Call the function
greet()  # Output: Hello, World!

Syntax:

def function_name(parameters):
    """Optional docstring"""
    # Function body
    return value  # Optional

Function with Parameters

Functions can accept inputs called parameters or arguments:

def greet_person(name):
    print(f"Hello, {name}!")

greet_person("Alice")  # Output: Hello, Alice!
greet_person("Bob")    # Output: Hello, Bob!

Multiple Parameters

def add_numbers(a, b):
    result = a + b
    print(f"{a} + {b} = {result}")

add_numbers(5, 3)  # Output: 5 + 3 = 8

The return Statement

Functions can return values using the return keyword:

def multiply(x, y):
    return x * y

result = multiply(4, 5)
print(result)  # Output: 20

Multiple Return Values

Python functions can return multiple values as a tuple:

def get_name_age():
    name = "John"
    age = 25
    return name, age

person_name, person_age = get_name_age()
print(f"Name: {person_name}, Age: {person_age}")
# Output: Name: John, Age: 25

Functions Without Return

If no return statement is used, the function returns None:

def say_hello():
    print("Hello!")

result = say_hello()  # Output: Hello!
print(result)         # Output: None

Default Arguments

You can provide default values for parameters:

def greet_with_title(name, title="Mr."):
    print(f"Hello, {title} {name}!")

greet_with_title("Smith")         # Output: Hello, Mr. Smith!
greet_with_title("Johnson", "Dr.") # Output: Hello, Dr. Johnson!

Multiple Default Arguments

def create_profile(name, age=18, country="USA"):
    print(f"Name: {name}, Age: {age}, Country: {country}")

create_profile("Alice")                    # Name: Alice, Age: 18, Country: USA
create_profile("Bob", 25)                  # Name: Bob, Age: 25, Country: USA
create_profile("Charlie", 30, "Canada")    # Name: Charlie, Age: 30, Country: Canada

Keyword Arguments

You can pass arguments by specifying the parameter name:

def book_info(title, author, year):
    print(f"'{title}' by {author} ({year})")

# Positional arguments
book_info("1984", "George Orwell", 1949)

# Keyword arguments
book_info(author="Jane Austen", title="Pride and Prejudice", year=1813)

# Mixed (positional first, then keyword)
book_info("Hamlet", author="Shakespeare", year=1600)

Variable-Length Arguments: *args

Use *args to accept any number of positional arguments:

def sum_all(*numbers):
    total = 0
    for num in numbers:
        total += num
    return total

print(sum_all(1, 2, 3))          # Output: 6
print(sum_all(1, 2, 3, 4, 5))    # Output: 15
print(sum_all(10))               # Output: 10

Combining Regular Parameters with *args

def introduce(name, *hobbies):
    print(f"Hi, I'm {name}!")
    if hobbies:
        print("My hobbies are:", ", ".join(hobbies))

introduce("Alice")                           # Hi, I'm Alice!
introduce("Bob", "reading", "swimming")      # Hi, I'm Bob!
                                           # My hobbies are: reading, swimming

Variable-Length Keyword Arguments: **kwargs

Use **kwargs to accept any number of keyword arguments:

def display_info(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

display_info(name="John", age=25, city="New York")
# Output:
# name: John
# age: 25
# city: New York

Combining *args and **kwargs

def flexible_function(*args, **kwargs):
    print("Positional arguments:", args)
    print("Keyword arguments:", kwargs)

flexible_function(1, 2, 3, name="Alice", age=30)
# Output:
# Positional arguments: (1, 2, 3)
# Keyword arguments: {'name': 'Alice', 'age': 30}

Function Parameter Order

When combining different types of parameters, follow this order:

def complete_function(required, default="value", *args, **kwargs):
    print(f"Required: {required}")
    print(f"Default: {default}")
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

complete_function("must_have", "custom", 1, 2, 3, extra="info")
# Output:
# Required: must_have
# Default: custom
# Args: (1, 2, 3)
# Kwargs: {'extra': 'info'}

Scope and Local vs Global Variables

Local Scope

Variables defined inside a function are local:

def my_function():
    local_var = "I'm local"
    print(local_var)

my_function()  # Output: I'm local
# print(local_var)  # Error: local_var is not defined

Global Scope

Variables defined outside functions are global:

global_var = "I'm global"

def access_global():
    print(global_var)  # Can read global variable

access_global()  # Output: I'm global

Modifying Global Variables

Use the global keyword to modify global variables inside functions:

counter = 0

def increment():
    global counter
    counter += 1

increment()
print(counter)  # Output: 1

Docstrings

Document your functions using docstrings:

def calculate_area(length, width):
    """
    Calculate the area of a rectangle.

    Args:
        length (float): The length of the rectangle
        width (float): The width of the rectangle

    Returns:
        float: The area of the rectangle
    """
    return length * width

# Access docstring
print(calculate_area.__doc__)

Lambda Functions

Lambda functions are small, anonymous functions defined using the lambda keyword:

# Regular function
def square(x):
    return x ** 2

# Lambda equivalent
square_lambda = lambda x: x ** 2

print(square(5))        # Output: 25
print(square_lambda(5)) # Output: 25

Lambda with Multiple Arguments

# Lambda with multiple arguments
add = lambda x, y: x + y
print(add(3, 7))  # Output: 10

# Lambda with default arguments
greet = lambda name="World": f"Hello, {name}!"
print(greet())        # Output: Hello, World!
print(greet("Alice")) # Output: Hello, Alice!

Practical Examples

Example 1: Temperature Converter

def celsius_to_fahrenheit(celsius, precision=2):
    """Convert Celsius to Fahrenheit with specified precision."""
    fahrenheit = (celsius * 9/5) + 32
    return round(fahrenheit, precision)

print(celsius_to_fahrenheit(25))     # Output: 77.0
print(celsius_to_fahrenheit(0, 1))   # Output: 32.0

Example 2: Shopping Cart Calculator

def calculate_total(*prices, tax_rate=0.08, discount=0):
    """Calculate total price with tax and discount."""
    subtotal = sum(prices)
    discounted = subtotal - (subtotal * discount)
    total = discounted + (discounted * tax_rate)
    return round(total, 2)

# Usage examples
print(calculate_total(10.99, 25.50, 8.75))
# Output: 48.87

print(calculate_total(10.99, 25.50, tax_rate=0.10, discount=0.15))
# Output: 34.19

Example 3: User Registration System

def register_user(username, email, **additional_info):
    """Register a new user with optional additional information."""
    user = {
        "username": username,
        "email": email,
        "status": "active"
    }

    # Add any additional information
    user.update(additional_info)

    print(f"User {username} registered successfully!")
    return user

# Usage
new_user = register_user(
    "alice_dev",
    "[email protected]",
    age=28,
    location="New York",
    skills=["Python", "JavaScript"]
)

print(new_user)

Best Practices

1. Use Descriptive Names

# Good
def calculate_monthly_payment(principal, rate, months):
    return (principal * rate) / (1 - (1 + rate) ** -months)

# Avoid
def calc(p, r, m):
    return (p * r) / (1 - (1 + r) ** -m)

2. Keep Functions Small and Focused

# Good - Single responsibility
def validate_email(email):
    return "@" in email and "." in email

def send_welcome_email(email):
    if validate_email(email):
        print(f"Welcome email sent to {email}")

# Better than one large function doing everything

3. Use Type Hints (Python 3.5+)

def add_numbers(a: int, b: int) -> int:
    """Add two integers and return the result."""
    return a + b

def greet_user(name: str, times: int = 1) -> None:
    """Greet a user a specified number of times."""
    for _ in range(times):
        print(f"Hello, {name}!")

Summary

Concept Description Example
def Define a function def my_func():
return Return a value return result
Parameters Function inputs def func(a, b):
Default args Parameters with defaults def func(a, b=10):
*args Variable positional arguments def func(*args):
**kwargs Variable keyword arguments def func(**kwargs):
Lambda Anonymous function lambda x: x * 2
Docstring Function documentation """Function description"""

Functions are fundamental building blocks in Python that make code reusable, organized, and maintainable. Master these concepts to write clean and efficient Python programs!