def Keyword

What Will You Learn
In this section, you’ll explore the purpose and syntax of the def keyword in Python. You’ll learn how to define your own functions, choose meaningful names, use indentation properly, and structure parameters. This knowledge gives you the foundation to write reusable, maintainable code and begin modular programming with confidence in any Python project.

In Python, the def keyword is used to define a function. Functions are reusable blocks of code that can perform specific tasks. By using def, you give your code structure, improve readability, and eliminate repetition. For beginners, understanding how to define and use functions with def is a foundational skill. This keyword introduces a new function and creates its name, arguments, and code block.

Everything inside the function must be indented. Without def, your code would become cluttered and hard to maintain.

What Is the def Keyword in Python?

The def keyword in Python is used to define a new function. It marks the beginning of a function block, followed by the function name, parentheses (which may include parameters), and a colon. The indented block after def contains the logic that runs when the function is called. Functions defined with def may return a value using the return statement, but it's not mandatory. This keyword is fundamental to building modular and reusable code. Every Python function starts with def, making it a core part of the language's syntax. Without it, you can't declare custom functions. Once defined, the function can be reused any number of times in your program. It can also be passed to other functions or assigned to variables.

To write the def keyword in Python, follow these steps:

1. Start with the def keyword.
2. Provide a name for your function.
3. Include parentheses, optionally with parameters inside.
4. End the line with a colon (:).
5. Indent the following lines to define the function body.

Here is an example:

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

    result = add_numbers(5, 3)
    print("The sum is:", result)  # Output: The sum is: 8

In this example, the function add_numbers takes two parameters, a and b, adds them, and returns the result. You can call this function multiple times with different arguments to reuse the logic.

What Is the Purpose of the def Keyword in Python?

The primary purpose of def is to declare a user-defined function. It allows you to write logic once and reuse it multiple times. This simplifies your code, makes it cleaner, and reduces duplication. Functions improve modularity and help break large programs into smaller, manageable parts. Using def also enhances testability and collaboration, especially in large codebases.

Key Purposes of def in Python:

• Encapsulate logic. Group a block of related code under one name for reuse.
• Promote code reuse. Write once, call many times.
• Improve readability. Clearly name and separate logical units.
• Simplify debugging. Test smaller units independently.
• Support abstraction. Hide complex details behind a clean interface.
• Enable parameterization. Accept arguments and return values.
• Facilitate collaboration. Make code easier to understand and maintain for teams.

Using def is essential for any Python program, from simple scripts to large systems. Understanding how and why to use it is one of the first milestones in learning the language.

Python def Keyword Usage

The def keyword is always used at the beginning of a function definition in Python. It is followed by the function name and a pair of parentheses, which may include parameters. The line ends with a colon, and the function body is indented underneath. You can include any logic inside the body — conditionals, loops, or other function calls. Functions can accept zero or more arguments and can return values using the return keyword. A function must be defined before it is called; otherwise, Python will raise a NameError. You can call a function multiple times, with different arguments each time. Functions can also be nested inside other functions or passed as arguments. Using def consistently is key to writing clean, efficient, and modular Python code.

Here are some examples to demonstrate how to use the def keyword in Python:

Example 1: A Simple Greeting Function

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

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

Example 2: Function with Default Parameters

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

    greet()           # Output: Welcome, Guest!
    greet("Charlie")  # Output: Welcome, Charlie!
    

Example 3: Function Returning a Value

    def square(number):
        return number * number

    result = square(4)
    print("The square is:", result)  # Output: The square is: 16
    

Beginner Mistakes with def Keyword

1. Not Including a Colon After the Function Header

One of the most common mistakes is forgetting the colon at the end of the function definition line. Python requires a colon to signal the start of the indented block. Without it, a SyntaxError will occur.

Incorrect:

    def say_hello()
        print("Hello")

Correct:

    def say_hello():
        print("Hello")

2. Incorrect Indentation Inside the Function Body

Python uses indentation to define code blocks. If the code under def is not properly indented, it will result in an IndentationError.

Incorrect:

    def greet():
    print("Hi")

Correct:

    def greet():
        print("Hi")

3. Calling a Function Before It’s Defined

Python reads code from top to bottom. If you call a function before defining it, Python won't recognize the name.

Incorrect:

    say_hi()

    def say_hi():
        print("Hi")

Correct:

    def say_hi():
        print("Hi")

    say_hi()

4. Forgetting to Use Parentheses When Calling the Function

A very common beginner mistake is referencing a function name without parentheses, which doesn’t actually call the function.

Incorrect:

    def greet():
        print("Hello")

    greet  # does nothing

Correct:

greet()  # calls the function

5. Defining a Function Inside a Loop or Conditional Without Understanding Scope

Placing function definitions inside other control blocks (like if, while) without understanding scope can lead to unexpected behavior or inaccessibility.

Incorrect:

    if True:
        def show():
            print("Inside")
    show()  # NameError if condition was False

Correct:
Define functions at the top level unless there's a specific reason for nesting.

    def show():
        print("Inside")

FAQ — def keyword in Python

    def greet(name):
        print("Hello,", name)

    square = lambda x: x * x
    print(square(5))  # Output: 25

    count = 10

    def increment():
        global count
        count += 1

    def outer():
    def inner():
        print("Hello from inner")
    inner()

    greet(name):
        print("Hi", name)