Understanding Python Functions: Definitions, Parameters, and Calls

As an abstract way of representing code, functions play a crucial role in Python. This section introduces function definition, parameter passing, and invocation, focusing on the various parameter types.

Python uses the def statement to define a function, followed by the function name, parentheses with parameters, a colon, and an indented body. Example:

def f_abs(x):
    if x >= 0:
        return x
    else:
        return -x

If the function is saved in a file (e.g., abstest.py), it can be imported and called from the command line:

C:\Users\Administrator>F:
F:\>cd pythoncode>python
>>> from abstest import f_abs
>>> f_abs(-1.0923)
1.0923

Python functions can return multiple values (as a tuple) and can perform argument type checks.

Required parameters must be provided in order. Example of a simple square function:

def power(x):
    return x * x

power(-10)
100

When more arguments are needed, additional required parameters are added:

def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

power(10, 3)
1000

Default parameters provide fallback values and must follow required parameters. Example:

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

>>> power(10)
100
>>> power(10, 2)
100

Variable parameters (using *) allow an arbitrary number of positional arguments:

def jisuan(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

>>> nums = [2, 3, 5]
>>> jisuan(*nums)
38

Keyword parameters (using **) accept any number of named arguments as a dictionary:

def player(name, team, **kw):
    print('name:', name, 'team:', team, 'other:', kw)

player('Harden', 'Rockets', city='Houston')
# Output: name: Harden team: Rockets other: {'city': 'Houston'}

Keyword arguments can also be passed via a pre‑constructed dictionary:

info = {'city': 'Golden states'}
player('Curry', 'Warriors', **info)
# Output: name: Curry team: Warriors other: {'city': 'Golden states'}

Named keyword parameters restrict the allowed keyword arguments and require a * separator:

def player(name, team, *, city, age):
    print(name, team, city, age)

player('Parker', 'Spurs', city='San Antonio', age=32)
# Output: Parker Spurs San Antonio 32

When a function already has variable parameters, the * separator is not needed for named keyword parameters:

def player(name, team, *tec, city, age):
    print(name, team, tec, city, age)

Parameter order must follow: required > default > variable > named keyword > keyword.

Function calls are straightforward: use the function name with appropriate arguments. Built‑in functions such as abs, max, and int can be called directly:

>> abs(-0.3)
0.3
>>> max(3, 0, 8, 3)
8
>>> int(10.24)
10