Python function
last modified October 30, 2026 Python 3.15
In this article we cover functions in Python.
Python function definition
A function is a named block of code that maps zero or more input parameters to a result. A function is executed only when it is called.
The advantages of using functions are:
- Code organization
- Reducing duplication of code
- Decomposing complex problems into simpler pieces
- Improving clarity of the code
- Reuse of code
- Information hiding
Functions in Python are first-class citizens. It means that functions have equal status with other objects in Python. Functions can be assigned to variables, stored in collections, or passed as arguments. This brings additional flexibility to the language.
Python function types
There are two basic types of functions: built-in functions and user
defined functions. The built-in functions are part of the Python language;
for instance dir, len, or abs.
The user defined functions are functions created with the def
keyword.
Python creating functions
A function is created with the def keyword. The statements in
the block of the function must be indented.
def function():
pass
The def keyword is followed by the function name with round
brackets and a colon. The indented statements form the body of
the function. The pass statement does nothing; it is used
where a statement is required syntactically.
The function is later executed when needed. We say that we call the function. If we call a function, the statements inside the function body are executed. They are not executed until the function is called.
myfunc()
To call a function, we specify the function name with the round brackets.
Calling functions
The following example defines and calls two functions.
"""
The ret.py script shows how to work with
functions in Python.
"""
def show_module_doc():
print(__doc__)
def get_module_file():
return __file__
a = show_module_doc()
b = get_module_file()
print(a, b)
The string at the top of the script is called the documentation string. It documents the current script. The file in which we put Python code is called a module.
We define two functions. The first function prints the module
documentation string. The second returns the path of the module. A function
may or may not return a value. If a function does not return a value, it
implicitly returns None. The __doc__ and
__file__ are special module attributes. Note that there are
two underscores on both sides of the attribute.
$ python ret.py The ret.py script shows how to work with functions in Python. None /home/user/python/ret.py
Definition before use
A function must be defined before it is called. A def statement
is executed like any other statement; it creates the function object and
binds it to the name.
def f1():
print('f1()')
f1()
f2()
def f2():
print('f2()')
The f1 function is defined before it is called. The
f2 function is called before its def statement
was executed, so the interpreter raises a NameError.
$ python func_prec.py
f1()
Traceback (most recent call last):
File "/home/user/python/func_prec.py", line 6, in <module>
f2()
^^
NameError: name 'f2' is not defined. Did you mean: 'f1'?
Where to define functions
Functions can be defined inside modules, classes, or other functions. Functions defined inside a class are called methods.
class Info:
def say(self):
print('This is Info class')
class Some:
@staticmethod
def f():
print('f() static method')
def f():
print('f() plain function')
def g():
def f():
print('f() inner function')
f()
i = Info()
i.say()
Some.f()
f()
g()
In this example we define an f function in different places.
The say method is called on an instance of the
Info class. The static method, defined with the
@staticmethod decorator, is called on the Some
class name. The module-level f is a plain function. Inside
g, there is an inner f function, which is visible
only within g.
$ python defining.py This is Info class f() static method f() plain function f() inner function
Python functions are objects
Functions in Python are objects. They can be manipulated like other objects in Python.
def f():
"""This function prints a message"""
print('Today it is a cloudy day')
print(isinstance(f, object))
print(type(f))
print(id(f))
print(f.__doc__)
print(f.__name__)
g = f
g()
print(g.__name__)
The isinstance function checks that f is an
instance of object, the base of all Python objects. Like every
object, the function has a type and a unique id, and it has attributes; we
print the __doc__ and __name__ attributes. When we
assign the function to the g variable, both names refer to the
same function object.
$ python fun_obj.py True <class 'function'> 130789884034240 This function prints a message f Today it is a cloudy day f
Functions in collections
Functions can be stored in collections and passed to other functions.
def add(x, y):
return x + y
def sub(x, y):
return x - y
def mul(x, y):
return x * y
ops = {'+': add, '-': sub, '*': mul}
for sign, fn in ops.items():
print(f'7 {sign} 3 = {fn(7, 3)}')
def apply(fn, vals):
return [fn(v, v) for v in vals]
print(apply(add, [1, 2, 3]))
print(apply(mul, [1, 2, 3]))
We store three functions in a dictionary and call them by the operator
sign. The apply function takes another function as its first
parameter and calls it for each value. A function that takes or returns
another function is called a higher-order function.
$ python fun_coll.py 7 + 3 = 10 7 - 3 = 4 7 * 3 = 21 [2, 4, 6] [1, 4, 9]
Three kinds of functions in Python
Looking from a particular point of view, we can discern three kinds of
functions: built-in functions that are always available, functions
contained within modules, which must be imported, and functions defined by
a programmer with the def keyword.
from math import sqrt
def cube(x):
return x * x * x
print(abs(-1))
print(cube(9))
print(sqrt(81))
The abs function is a built-in function, readily accessible.
The sqrt function is imported from the math
module. The cube function is a custom defined function.
$ python three_kinds.py 1 729 9.0
Python return keyword
A function is created to do a specific task. Often there is a result from
such a task. The return keyword is used to return values from
a function. If a function does not have a return statement,
it returns None.
def show_message(msg):
print(msg)
def cube(x):
return x * x * x
x = cube(3)
print(x)
show_message('Computation finished.')
print(show_message('Ready.'))
The show_message function does not return a value explicitly;
it prints a message to the console. The cube function computes
an expression and returns its result, which we assign to the
x variable. The last line produces two lines: the message
printed by show_message and the None value
implicitly returned by it.
$ python returning.py 27 Computation finished. Ready. None
Returning multiple values
A function can return more than one value. The objects after the
return keyword are separated by commas.
def stats(vals):
mx = max(vals)
mn = min(vals)
total = sum(vals)
return mx, mn, len(vals), total
n = [1, 2, 3, 4, 5]
print(stats(n))
mx, mn, size, total = stats(n)
print(mx, mn, size, total)
The stats function returns four values. In fact, it returns a
tuple containing these four values. The tuple can be unpacked into separate
variables.
$ python returning2.py (5, 1, 5, 15) 5 1 5 15
Python function redefinition
Python is dynamic in nature. It is possible to redefine an already defined function.
from datetime import datetime
def show_message(msg):
print(msg)
show_message('Ready.')
def show_message(msg):
print(f'{datetime.now():%H:%M:%S} {msg}')
show_message('Processing.')
We define a show_message function and call it. Later we
provide a new definition of the same function, which precedes the message
with the current time. The second def statement rebinds the
show_message name to a new function object.
$ python redefinition.py Ready. 21:21:43 Processing.
Python function arguments
Most functions accept arguments. Arguments are values that are sent to the function. The names in the function definition are called parameters. The functions process the values and optionally return some value back.
def c2f(c):
return c * 9 / 5 + 32
print(c2f(100))
print(c2f(0))
print(c2f(30))
print(c2f(-40))
In our example, we convert Celsius temperature to Fahrenheit. The
c2f function accepts one argument c, which is the
Celsius temperature. The / operator always produces a float,
so the results are floats.
$ python fahrenheit.py 212.0 32.0 86.0 -40.0
Default parameter values
The parameters of Python functions may have default values. A default value is used if no argument is provided.
def power(x, y=2):
r = 1
for _ in range(y):
r = r * x
return r
print(power(3))
print(power(3, 3))
print(power(5, 5))
Here we created a power function. The y parameter has a
default value of 2. We can call the function with one or two arguments.
Parameters with default values must follow parameters without them.
$ python default_args.py 9 27 3125
Mutable default values
Default values are evaluated only once, when the def statement
is executed. A mutable default value, such as a list, is therefore shared
by all calls of the function.
def add_item(item, items=[]):
items.append(item)
return items
print(add_item('sky'))
print(add_item('owl'))
def add_item2(item, items=None):
if items is None:
items = []
items.append(item)
return items
print(add_item2('sky'))
print(add_item2('owl'))
The add_item function keeps adding to the same list object, so
the second call returns both items. The usual fix is to use
None as the default and create a new list inside the function,
as in add_item2.
$ python mutable_default.py ['sky'] ['sky', 'owl'] ['sky'] ['owl']
Keyword arguments
Python functions can be called with keyword arguments. This means that when calling a function, we specify both the parameter name and a value. When arguments are passed without keywords, the order in which we pass them is crucial. With keywords, the order does not matter.
def display(name, age, sex):
print(f'Name: {name}, Age: {age}, Sex: {sex}')
display('Lary', 43, 'M')
display(age=24, name='Joan', sex='F')
display('Paul', sex='M', age=31)
The first call uses positional arguments. The second call uses keyword arguments in a different order than the parameters. The third call mixes both: a positional argument may be followed by keyword arguments.
$ python keyword_args.py Name: Lary, Age: 43, Sex: M Name: Joan, Age: 24, Sex: F Name: Paul, Age: 31, Sex: M
Positional argument after keyword argument
A positional argument cannot follow a keyword argument.
def display(name, age, sex):
print(f'Name: {name}, Age: {age}, Sex: {sex}')
display(age=24, name='Joan', 'F')
This is a syntax error; the program is not even started.
$ python keyword_args2.py
File "/home/user/python/keyword_args2.py", line 5
display(age=24, name='Joan', 'F')
^
SyntaxError: positional argument follows keyword argument
Positional-only and keyword-only parameters
The / and * markers in a parameter list restrict
how arguments can be passed. Parameters before / are
positional-only, parameters after * are keyword-only.
def describe(name, /, age, *, city):
print(f'{name} is {age} years old and lives in {city}')
describe('Lucia', 23, city='Bratislava')
describe('Peter', age=41, city='Košice')
try:
describe(name='Jana', age=30, city='Nitra')
except TypeError as e:
print(e)
try:
describe('Martin', 52, 'Žilina')
except TypeError as e:
print(e)
The name parameter can be passed only by position, the
age parameter either way, and the city parameter
only by keyword. Positional-only parameters let the author rename them
later without breaking callers; keyword-only parameters make calls with
many options readable.
$ python special_params.py Lucia is 23 years old and lives in Bratislava Peter is 41 years old and lives in Košice describe() got some positional-only arguments passed as keyword arguments: 'name' describe() takes 2 positional arguments but 3 were given
Arbitrary number of positional arguments
Functions in Python can accept an arbitrary number of arguments.
def do_sum(*args):
"""Return the sum of all values"""
print(type(args), args)
r = 0
for i in args:
r += i
return r
print(do_sum.__doc__)
print(do_sum(1, 2, 3))
print(do_sum(1, 2, 3, 4, 5))
print(do_sum())
We use the * operator to indicate that the function accepts an
arbitrary number of positional arguments. They are collected into a tuple.
The do_sum function returns the sum of all arguments. The
first string in the function body is the function's documentation string.
$ python arbitrary_args.py Return the sum of all values <class 'tuple'> (1, 2, 3) 6 <class 'tuple'> (1, 2, 3, 4, 5) 15 <class 'tuple'> () 0
Arbitrary number of keyword arguments
With the ** operator, a function accepts an arbitrary number
of keyword arguments. They are collected into a dictionary.
def display(**details):
print(type(details))
for key, value in details.items():
print(f'{key}: {value}')
display(name='Larry', age=43, sex='M')
We can provide an arbitrary number of key-value arguments. The function handles them all. Dictionaries keep the insertion order, so the arguments are printed in the order in which they were passed.
$ python details.py <class 'dict'> name: Larry age: 43 sex: M
Combining parameter kinds
The different kinds of parameters can be combined in one function. The
order is: positional parameters, *args, keyword-only
parameters, and **kwargs.
def log(level, *args, sep=' ', **kwargs):
print(level, sep.join(map(str, args)), kwargs)
log('INFO', 'server started')
log('WARN', 'disk', 'almost', 'full', sep='_', used='93%')
The log function has one regular parameter, collects the
remaining positional arguments in args, has a keyword-only
sep parameter with a default value, and collects other keyword
arguments in kwargs. This is the same scheme that the built-in
print function uses.
$ python all_kinds.py
INFO server started {}
WARN disk_almost_full {'used': '93%'}
Unpacking function return values
Unpacking is cutting an object, such as a list, into its elements. It is
also called destructuring. The * operator collects all the
remaining elements into a list. By convention, the _ name is
used for values we want to ignore.
def fn():
return [1, 2, 3, 4, 5, 6]
a, b, c, d, e, f = fn()
print(a, b, c, d, e, f)
a, *mid, b = fn()
print(a, mid, b)
a, b, c, *_ = fn()
print(a, b, c)
a, b, c, *d = fn()
print(a, b, c, d)
*a, b, c, d = fn()
print(a, b, c, d)
We have a function that returns a list of values. First, all six values
are unpacked into six variables. The starred mid variable
takes all values but the first and the last one. With *_, we
ignore the last three values. The starred variable can be at any position;
*d takes the remaining values and *a takes the
first three values.
$ python unpacking.py 1 2 3 4 5 6 1 [2, 3, 4, 5] 6 1 2 3 1 2 3 [4, 5, 6] [1, 2, 3] 4 5 6
Unpacking function arguments
We can unpack values into function arguments. The * operator
unpacks an iterable into positional arguments and the **
operator unpacks a dictionary into keyword arguments.
def fn(a, b, c, d, e, f):
print(a, b, c, d, e, f)
def fn2(a, b, c, *d):
print(a, b, c, d)
def fn3(a, b, c, *d, e, f):
print(a, b, c, d, e, f)
def user(name, occupation):
print(f'{name} is a {occupation}')
vals = [1, 2, 3, 4, 5, 6]
fn(*vals)
fn2(*vals)
fn3(*vals, e=7, f=8)
data = {'name': 'John Doe', 'occupation': 'gardener'}
user(**data)
We unpack a list into the arguments of three functions. Since the
d parameter of fn3 collects the remaining
positional arguments, the e and f parameters must
be passed as keyword arguments. Finally, the dictionary keys are matched
with the parameter names of the user function.
$ python unpacking2.py 1 2 3 4 5 6 1 2 3 (4, 5, 6) 1 2 3 (4, 5, 6) 7 8 John Doe is a gardener
Passing arguments
Python passes arguments by assignment: the parameter becomes a new name for the object that was passed. No copy is made. This is sometimes called call by sharing.
def modify(x):
x.pop()
x.insert(0, 0)
print('Inside modify():', x)
def rebind(x):
x = [10, 20, 30]
print('Inside rebind():', x)
n = [1, 2, 3, 4, 5]
print('Original list:', n)
modify(n)
print('After modify():', n)
rebind(n)
print('After rebind():', n)
The modify function changes the list object it received, so
the change is visible outside the function. The rebind
function assigns a new list to its local x name; this does not
affect the caller's n variable. Immutable objects, such as
numbers or strings, cannot be changed in place, so a function can never
modify them for the caller.
$ python passing_args.py Original list: [1, 2, 3, 4, 5] Inside modify(): [0, 1, 2, 3, 4] After modify(): [0, 1, 2, 3, 4] Inside rebind(): [10, 20, 30] After rebind(): [0, 1, 2, 3, 4]
Python local variables
A variable assigned in a function body has a local scope. It is valid only within the body of the function.
name = 'Jack'
def f():
name = 'Robert'
print('Within function', name)
def g():
print('Within function', name)
print('Outside function', name)
f()
g()
print('Outside function', name)
The f function creates a local name variable,
which hides the global one; the global variable is not changed. The
g function does not assign to name, so it reads
the global variable.
$ python local_variable.py Outside function Jack Within function Robert Within function Jack Outside function Jack
Python global variables
If we want to change a global variable in a function, we must use the
global keyword.
name = 'Jack'
def f():
global name
name = 'Robert'
print('Within function', name)
print('Outside function', name)
f()
print('Outside function', name)
Using the global keyword, we reference the variable defined
outside the body of the function. The variable is given a new value, which
is visible after the function call.
$ python global_variable.py Outside function Jack Within function Robert Outside function Robert
UnboundLocalError
Python decides at compile time whether a name inside a function is local. A name that is assigned anywhere in the function body is local in the whole body.
counter = 0
def increment():
counter += 1
try:
increment()
except UnboundLocalError as e:
print(e)
The counter += 1 statement assigns to counter, so
counter is a local variable. Reading it before the assignment
raises an UnboundLocalError. A global counter
statement would fix it.
$ python unbound_local.py cannot access local variable 'counter' where it is not associated with a value
Closures and nonlocal
An inner function can use the variables of its enclosing function, even
after the enclosing function has returned. Such a function is called a
closure. To assign to a variable of the enclosing function, we use
the nonlocal keyword.
def make_counter():
count = 0
def counter():
nonlocal count
count += 1
return count
return counter
c1 = make_counter()
c2 = make_counter()
print(c1(), c1(), c1())
print(c2())
The make_counter function returns the inner
counter function. Each returned function remembers its own
count variable, so the two counters are independent. There is a
Python closures tutorial on ZetCode.
$ python closure.py 1 2 3 1
Recursive functions
A function can call itself. Such a function is called recursive. A recursive function must have a base case that stops the recursion.
import sys
def factorial(n):
if n <= 1:
return 1
return n * factorial(n - 1)
print(factorial(5))
print(factorial(20))
print(sys.getrecursionlimit())
The factorial function computes the factorial of a number;
the base case is n <= 1. Python integers have arbitrary
precision, so large results are exact. The recursion depth is limited; the
default limit is 1000 frames, and exceeding it raises a
RecursionError.
$ python recursion.py 120 2432902008176640000 1000
Function annotations
Parameters and return values can be annotated with type hints. The annotations are not enforced by the interpreter; they are used by type checkers, editors, and documentation tools.
import inspect
def area(width: float, height: float = 1.0) -> float:
return width * height
def make_user(name: str) -> User:
return User(name)
class User:
def __init__(self, name: str):
self.name = name
print(area(3, 4.5))
print(area('ab', 3))
print(area.__annotations__)
print(inspect.signature(area))
print(make_user.__annotations__)
The area function accepts strings as well, because Python does
not check the annotations. They are stored in the
__annotations__ attribute and are shown by
inspect.signature. Since Python 3.14, annotations are evaluated
lazily, when they are first accessed. Therefore make_user can
refer to the User class, which is defined later in the module.
In Python 3.13 and earlier, the annotation is evaluated when the function is
defined, which raises a NameError.
$ python annotations.py
13.5
ababab
{'width': <class 'float'>, 'height': <class 'float'>, 'return': <class 'float'>}
(width: float, height: float = 1.0) -> float
{'name': <class 'str'>, 'return': <class '__main__.User'>}
$ python3.13 annotations.py
Traceback (most recent call last):
File "/home/user/python/annotations.py", line 8, in <module>
def make_user(name: str) -> User:
^^^^
NameError: name 'User' is not defined
Python anonymous functions
It is possible to create anonymous functions in Python. Anonymous functions
do not have a name. With the lambda keyword, little anonymous
functions can be created. Anonymous functions are also called lambda
functions. They are restricted to a single expression. There is a
Python lambda functions tutorial on ZetCode.
y = 6 z = lambda x: x * y print(z(8)) cs = [-10, 0, 15, 30, 40] ft = map(lambda t: 9 / 5 * t + 32, cs) print(list(ft)) words = ['sky', 'Falcon', 'owl', 'Arrow', 'cup'] print(sorted(words, key=lambda w: w.lower()))
The x is a parameter of the lambda function. It is followed by
a colon and the expression that is evaluated when the function is called.
The lambda is assigned to the z variable; when called with 8,
it returns 48. The map function applies an anonymous function
to each element of a list of Celsius temperatures. The sorted
function uses a lambda as the key, so the words are sorted case-insensitively.
$ python lambda_fun.py 48 [14.0, 32.0, 59.0, 86.0, 104.0] ['Arrow', 'cup', 'Falcon', 'owl', 'sky']
Source
Defining functions - Python tutorial
In this article we covered Python functions.
Author
List all Python tutorials.