Lameck Odhiambo

Posted on Oct 3 Edited on Oct 5

Python Functions

#python #ai #programming

Python functions are reusable blocks of code designed to perform a specific task. They help prevent code repetition, break complex programs into smaller manageable pieces, and only run when explicitly called.

Basic Syntax - Defining and Calling a Function

Functions are defined using the def keyword, followed by a custom name, parentheses (), and a colon :. The body of the function must be indented.

# 1. Defining the function
def greet():
    print("Hello! Welcome to Python.")

# 2. Calling the function
greet()

Parameter vs Arguments

Parameters are names used in a function defination that describes what data the function expects.
Arguments are the actual values passed in a function call that are assigned to parameters.

def greet_user(username):  # username is a parameter
    print(f"Hello, {username}!")

greet_user("Alice")       # "Alice" is an argument

Core Argument Types

Positional

Values map directly to parameters based on the order they are written.

# 'name' is the first parameter, 'age' is the second
def greet(name, age):
    print(f"Hello {name}, you are {age} years old.")

# Calling the function using positional arguments
greet("Alice", 25)  
# Output: Hello Alice, you are 25 years old.

Keyword

Keyword argument (or named argument) is an argument passed to a function by explicitly stating the parameter name and its value using the syntax parameter_name = value

def greet_user(name, greeting, punctuation="!"):
    return f"{greeting}, {name}{punctuation}"

# 1. Standard positional call (order matters)
print(greet_user("Alice", "Hello"))  # Output: Hello, Alice!

# 2. Keyword argument call (order doesn't matter)
print(greet_user(greeting="Hi", name="Bob"))  # Output: Hi, Bob!

# 3. Mixing both (positional MUST come first)
print(greet_user("Charlie", greeting="Welcome", punctuation="."))  # Output: Welcome, Charlie.

Default argument

Default argument is a fallback value assigned to a function parameter during its definition. If you omit that argument when calling the function, Python automatically uses this predefined default value; if you provide a value, it overrides the default

def greet(name="Guest"):
    print(f"Hello, {name}!")

greet()        # Output: Hello, Guest! (Uses default)
greet("Alice") # Output: Hello, Alice! (Overrides default)

Args

*args is a special syntax used in function definitions to allow a function to accept a variable number of positional arguments.

def multiply_all(*args):
    result = 1
    # args is treated as a tuple: (2, 3, 4)
    for number in args:
        result *= number
    return result

# You can call the function with any number of inputs
print(multiply_all(2, 3))        # Output: 6
print(multiply_all(2, 3, 4, 5))  # Output: 120

Kwargs

**kwargs stands for keyword arguments. It is a special syntax used in function definitions to allow a function to accept an arbitrary (variable) number of named arguments
The values are stored in a dictionary.

def display_info(**kwargs):
    # kwargs is a dictionary inside the function
    print(kwargs) 

# Calling the function with different keyword arguments
display_info(name="Alice", age=30, city="New York")
# Output: {'name': 'Alice', 'age': 30, 'city': 'New York'}

Return Values

Use the return statement to exit a function and send data back to the program. If no return statement is defined, the function automatically returns None.

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

result = add_numbers(5, 10)
print(result)  # Output: 15

You can return multiple values by separating them with commas. Python automatically packs them into a tuple, which you can then unpack into separate variables

def get_user_data():
    name = "Bob"
    age = 25
    return name, age  # Returns a tuple: ("Bob", 25)

user_name, user_age = get_user_data()  # Unpacking
print(user_name)  # Output: Bob

Lambda Functions

In Python, a lambda function is a small, anonymous (unnamed) function that is defined in a single line of code. It is created using the lambda keyword and is typically used for short, temporary operations.

Syntax:

lambda arguments: expression

Examples

# Regular function
def add_ten_def(x):
    return x + 10

# Lambda function
add_ten = lambda x: x + 10

print(add_ten(5))  # Output: 15

add = lambda x, y: x + y
print(add(3, 5))  # Output: 8

Using with filter()

Filters an iterable by keeping only elements that return True for a specific condition

numbers = [1, 2, 3, 4, 5, 6]
# Keep only even numbers
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # Output: [2, 4, 6]

Using with map()

Applies a transformation to every element in an iterable

numbers = [1, 2, 3, 4]
# Square each number
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # Output: [1, 4, 9, 16]

Conclusion

Python functions are the fundamental building blocks of clean, efficient, and reusable code. They allow developers to group a specific block of logic together, reducing repetition and making complex programs manageable.

DEV Community