How to Define a Function in Python: Step-by-Step

Defining a function in Python lets you package a block of code under a name so you can reuse it without rewriting the logic. You give the function a name, optionally list parameters it accepts, and write the body that runs when it is called. This guide walks through the syntax, common pitfalls, and troubleshooting for creating your own functions.

What You’ll Need

Python 3 installed (any recent version works; the examples use Python 3.8+).
A text editor or IDE (like VS Code, PyCharm, or even Notepad).
A way to run Python: terminal/command prompt, or an interactive environment like Jupyter Notebook.

Step-by-Step

Open your editor and create a new Python file (e.g., my_functions.py) or start a Python interactive session.
Start with the def keyword, followed by a space, then the function name. Function names should be lowercase with underscores between words (snake_case). For example: def calculate_area():
Add parentheses immediately after the name. Inside them, list any parameters (inputs) the function needs, separated by commas. If no inputs are needed, leave the parentheses empty. Example: def calculate_area(length, width):
End the line with a colon (:). This tells Python that the indented block that follows is the function body.
Press Enter and indent the next line by 4 spaces (or one tab). All lines that belong to the function must have the same indentation. This is how Python knows what code is inside the function versus outside.
Write the function body – the statements that execute when the function is called. This can be calculations, print statements, loops, or anything else. Example: area = length * width
Use return to send a value back to the caller. If you don’t include return, the function returns None by default. Write return area to give the result back.
Call the function by typing its name followed by parentheses, passing the required arguments. Example: result = calculate_area(5, 3)
Use the returned value – print it, store it in a variable, or use it in further calculations. Example: print(result) prints 15.

Here’s a complete, minimal example:

def greet(name):
    return "Hello, " + name + "!"

print(greet("Alice"))

When you run this, it outputs Hello, Alice!.

Common Mistakes

Forgetting the colon at the end of the def line. Python raises a SyntaxError.
Inconsistent indentation – mixing spaces and tabs, or using different numbers of spaces. Python requires uniform indentation within a block.
Not returning a value when you expect one. If you omit return, the function returns None, which can cause errors like TypeError: unsupported operand type(s) if you try to use it in arithmetic.
Mismatched parameter count – calling a function with more or fewer arguments than it was defined with. This raises a TypeError.
Using a function before defining it – Python executes code top‑to‑bottom, so the definition must appear before the call in the file (unless the call is inside another function that runs later).
Shadowing built‑ins – naming your function list or sum can cause confusing behavior. Use distinct names.

Tips

Use descriptive names – calculate_area is better than calc or func1.
Add docstrings – a triple‑quoted string right after the def line that explains what the function does. This helps others and your future self.
Keep functions small – each function should do one thing. If it’s doing too much, split it.
Use default parameter values for optional inputs: def greet(name, greeting="Hello"): allows calling greet("Bob") or greet("Bob", "Hi").
Test with simple inputs – try your function with known values to verify it works.
Remember that variables inside a function are local – they don’t affect variables outside unless you use global (which is rarely needed).

Troubleshooting

SyntaxError: invalid syntax – Check for a missing colon, unmatched parentheses, or stray characters. Look at the line number in the error message.

NameError: name ‘my_function’ is not defined – The function hasn’t been defined yet, or the name is misspelled. Ensure the def statement appears before the call, and check spelling.

TypeError: my_function() takes 2 positional arguments but 3 were given – You passed too many arguments. Either add a parameter to the definition or remove an argument from the call.

TypeError: unsupported operand type(s) for +: ‘NoneType’ and ‘str’ – The function returned None because you forgot return. Add a return statement with the value you want.

IndentationError: unexpected indent – Extra spaces or tabs before a line that shouldn’t be indented. Check that all lines in the function body have the same indentation, and that lines outside the function are not indented.

Function returns the wrong value – Step through your logic with print statements inside the function to see intermediate values. Verify your formula and that you are returning the correct variable.

Function works when called once but fails later – Check if you are modifying a default argument or a global variable unintentionally. Use immutable defaults (like None) and assign inside the function.

Frequently Asked Questions

Q: Do I have to use return in every function?
A: No. If you just want the function to perform an action (like printing), you can omit return. The function will return None automatically.

Q: Can a function have multiple return values?
A: Yes. You can return a tuple: return x, y. The caller can unpack it: a, b = my_function().

Q: What is the difference between a parameter and an argument?
A: A parameter is the variable listed in the function definition (like length). An argument is the actual value you pass when calling the function (like 5).

Q: Can I call a function from inside another function?
A: Yes. Define one function, then call it within the body of another. This is a common way to structure code.

Q: How do I make a function that accepts any number of arguments?
A: Use *args for positional arguments and **kwargs for keyword arguments. Example: def my_func(*args): – then args is a tuple of all passed values.

Q: Why does my function not modify a list I pass to it?
A: In Python, lists are mutable, so modifications like append() do affect the original. But reassigning the parameter (my_list = [1,2]) only changes the local reference. To modify the original, use methods that change the object in place.

General steps for current mainstream versions; menus can differ by device and version. See the disclaimer or report an error.

More in this bed

The whole Tech How-To bed →