Python Functions A Complete Guide for Beginner

Functions are one of the most powerful features in Python. They help you organize your code, reuse logic, and write clean programs. In this Python Functions Complete Guide, you will learn everything about functions with simple explanations, clear examples, and real-world use cases.

Before continuing, you can explore related guides here:

• Master Python Lists: Methods & Use Cases
• Python Functions A Complete Guide for Beginner
• Python Numbers and Strings Explained in Depth

What Is a Functions in Python ?

A function is a reusable block of code that performs a specific task.
Instead of writing the same code again and again, you can define a function once and use it anywhere.

Why do we use Python functions?

• They make code clean.
• They reduce repetition.
• They make programs easier to debug.
• They help in modular programming.

How to Create a Python Function

To create a function, Python uses the def keyword. After that, you write the function name, parentheses, and a colon.

Inside the function block, you add the code that should run.

Syntax

        "def function_name():\n    # function body\n    print(\"Hello!\")\n"    

Example

        "def greet():\n    print(\"Welcome to Python!\")\n"    

Call the function

        "greet()\n"    

Whenever you call the function, Python executes the code inside it. Because of this behavior, functions allow you to reuse the same logic in different places.

Types of Functions in Python (Python Functions Complete Guide)

Python supports different types of functions.

Since each type serves a unique purpose, understanding them helps you write better code. Below is a simple breakdown with examples.

1. Built-in Functions

Python includes many built-in functions. Some common ones are print(), len(), max(), and sum().

        "print()\nlen()\ntype()\ninput()\nmax()\nmin()"    

For example:

        "items = [4, 8, 2]\nprint(max(items))\n"    

Since they come pre-installed, you can use them without writing any extra code.

1.1. Return Statement in Python

A function often sends back a value using the return keyword.

Example:

        "def square(n):\n    return n * n\n\nresult = square(6)\nprint(result)"    

This returned value can be stored, reused, or printed later.

2. User-Defined Functions

When Python’s built-in functions are not enough, you can create your own.

Example:

        "def add(a, b):\n    return a + b"    

User-defined functions give you full control. Although simple, this type of function gives you full control over how your program behaves.

3. Functions with Arguments

Functions become more powerful when you pass information into them.

These inputs are called arguments. Because arguments give functions flexibility, you can reuse the same function in many different situations.

Let’s explore every type of argument in Python with simple explanations and practical examples.

3.1. Positional Arguments

Positional arguments are the most common type.
Here, the order matters. Python matches each argument to its parameter by position.

Example:

        "def full_name(first, last):\n    print(first, last)\n\nfull_name(\"Ravi\", \"Kumar\")   # Correct order\n"    

If you change the order, the meaning also changes.

        "full_name(\"Kumar\", \"Ravi\")   # Wrong order\n"    

Because of this, positional arguments work best when the order is clear and fixed.

3.2. Keyword Arguments

Keyword arguments remove the restriction of order. Here, you mention the parameter name directly.

Example:

        "def user_info(name, age):\n    print(name, age)\n\nuser_info(age=25, name=\"Asha\")\n"    

Now the order does not matter. This makes your code more readable and reduces mistakes.

3.3. Default Arguments

Default arguments have a predefined value. If you do not pass a value, Python uses the default.

Example:

        "def greet(name=\"Guest\"):\n    print(\"Hello,\", name)\n\ngreet()             # Uses default\ngreet(\"mlopsbootcamp\")     # Overrides default"    

Default arguments are useful when your function should work even without inputs.

3.4. Variable-Length Arguments (*args)

Sometimes you do not know how many values a user will pass. In such cases, *args helps by accepting any number of positional arguments.

Example:

        "def total(*numbers):\n    print(numbers)\n    print(sum(numbers))\n\ntotal(10, 20, 30, 40)"    

Because *args collects values into a tuple, you can loop over them easily.

3.5. Variable-Length Keyword Arguments (**kwargs)

**kwargs allows multiple keyword arguments, similar to how dictionaries work.

Example:

        "def user_details(**info):\n    print(info)\n\nuser_details(name=\"Teja\", age=28, city=\"Hyderabad\")\n"    

Since **kwargs collects data as key–value pairs, it is perfect for flexible functions.

3.6. Combining All Argument Types

Python allows you to use multiple argument types in the same function.
However, the order is very important.

The correct order is:

1️⃣ Positional arguments
2️⃣ *args
3️⃣ Keyword arguments
4️⃣ **kwargs

Example:

        "def example(a, b, *args, c=10, **kwargs):\n    print(a, b)\n    print(args)\n    print(c)\n    print(kwargs)\n\nexample(1, 2, 3, 4, 5, c=20, x=100, y=200)\n"    

Because this order avoids confusion, Python enforces it strictly.

3.7. Passing Functions as Arguments

Python treats functions as first-class citizens. This means you can pass a function as an argument to another function.

Example:

        "def apply(func, value):\n    return func(value)\n\ndef square(n):\n    return n * n\n\nprint(apply(square, 5))\n"    

3.8. Unpacking Arguments

You can also unpack lists and dictionaries when passing them to functions.

3.8.1 Unpacking a list:

        "def add(a, b, c):\n    print(a + b + c)\n\nnums = [2, 4, 6]\nadd(*nums)\n"    

3.8.2 Unpacking a dictionary:

        "def intro(name, age):\n    print(name, age)\n\ndata = {\"name\": \"Asha\", \"age\": 22}\nintro(**data)"    

This feature makes Python functions extremely flexible and convenient.

5. Lambda (Anonymous) Functions

Lambda is a one-line function without a name.

Example:

        "square = lambda x: x * x\nprint(square(7))"    

        "add = lambda a, b: a + b\nprint(add(2, 3))"    

Lambda functions are perfect for quick and simple operations.
They are often used with:

• map()
• filter()
• sorted()
• Data analysis tasks

6. Nested Functions (Function Inside Function)

Python allows functions inside other functions.

        "def outer():\n    def inner():\n        print(\"Inside inner function\")\n    inner()\n\nouter()"    

7. Recursion in Python

A recursive function calls itself.

Example:

        "def factorial(n):\n    if n == 1:\n        return 1\n    return n * factorial(n - 1)\n\nprint(factorial(5))"    

Best Practices for Writing Python Functions

• Use meaningful function names.
• Keep functions small and simple.
• Use comments and docstrings.
• Return values instead of printing, when needed.
• Avoid too many arguments (use *args or **kwargs instead).
• Follow PEP 8 naming guidelines.