Introduction to Python Functions, Parameters, Return Values; Define and Call Python Functions

Define Python Functions

Typically, Python functions are defined in modules and serve as targets that can be called externally, and are written in the following basic format.

def <funcname>(<parameterlist>)
    <docstring>
    <block>

funcname part

funcname is the name of the function, which needs to conform to Python's identifier specification, and cannot use Python keywords or reserved keywords.

parameterlist part

parameterlist is the parameter list of a function, which defines all the parameters of the function, separated by ,.

docstring part

docstring is the documentation string for the function and contains a description of the function, this is not mandatory, a function can have no documentation string.

block part

block is the body code of the function, and both it and docstring need to be indented with some kind of whitespace character to indicate that they belong to the function.

# Define a function hello with the parameter name
def hello(name):
	'''A super simple function'''
	print(f'Hello, {name}')

Call Python Functions

Calling functions is an easy task in any language, and this is true for Python as well; here is the basic format for calling functions.

<funcname>(<argumentlist>)

funcname part

funcname is the name of the function to be called.

argumentlist part

argumentlist is the list of arguments passed to the function.

# Call the function hello
hello('Kitty')

Hello, Kitty

Python Code Indentation

Python illustrates code hierarchy through indentation, which is generally accomplished by using spaces or tabs. Code with the same number of spaces or tabs, counting from the beginning of the line, is considered to be at the same level.

Parameters of Python Functions

Python functions can have default values for their parameters, which can be set with = when defined. The default value is calculated only once, so the default value of the parameter points to the same object. If the default value is a list, the list may contain different elements each time the function is called.

# Define the addition function
def add(x=1, y=[], /, *, z):
	# Add the number 100 to the list y
	y.append(100)
	print(y)


	# Calculate the sum of the numbers contained in x, y, and z
	num = 0
	for i in y:
		num += i


	return x + num + z


# z can only be used as a keyword parameter
print(add(z=1))
# x is used as a positional parameter
print(add(1, z=3))

[100]
102
[100, 100]
204

Variadic Parameters of Python Functions

When you add * or ** in front of a Python function’s parameter, the parameter becomes a variadic parameter. The parameter marked with the symbol * is a tuple that contains all the positional parameters that are not in the parameter list at the time the function is called. The parameter marked with the symbol ** is a dictionary, which should be located at the end of the parameter list, and contains all the keyword parameters that are not in the parameter list when the function is called. The key of the dictionary key-value pair is a string that represents the name of the parameter, and the value of the key-value pair is the corresponding value of the parameter.

If both * and ** are used in the parameter list, the * needs to have the parameter name after it.

# Define the multiplication function
def mlp(*nums, **info):
	# Show keyword parameters
	print(info)


	# Calculate the positional parameters contained in nums
	num = 1
	for i in nums:
		num *= i


	return num


# Pass multiple numbers for multiplication
print(mlp(2, 3, 4, 5, tip='Here is a little hint'))

{'tip': 'Here is a little hint'}
120

Return Values of Python Functions

With the return statement, you can return a specified value for a Python function; if return is not used or return does not give a return value, the function returns None by default.

Signatures of Python Functions

By default, the signature of a Python function contains only the name of the function, which means that a function defined later in the same namespace overrides a function of the same name defined earlier, regardless of its parameters and return value.

# This function will be overridden by the wait function defined later
def wait(seconds):
	print(f'Wait {seconds} second(s)')


# The first defined wait function is called
wait(3)


# This function overrides the previously defined wait function
def wait(hours, minutes=5):
	print(f'Wait {hours} hour(s) {minutes} minute(s)')


# The last defined wait function is called
wait(3)

Wait 3 second(s)
Wait 3 hour(s) 5 minute(s)

Namespaces of Python Functions

Yes, Python functions have their own namespace, so variables you define inside a function can have the same name as variables outside the function, and they will be treated differently.

# Define the variable message in the module
message = 'I am a module variable'


# The show function defines its own message
def show():
	# This does not modify the message defined by the module
	message = 'I am a variable in the function'
	print(message)


# The show_again function uses the message variable defined by the module
def show_again():
	print(message)


show()
show_again()

I am a variable in the function
I am a module variable

Comments of Python Functions

Writing documentation strings for Python functions makes it easy for developers to understand how to use the functions, but of course this requires that the development tools have the appropriate code hints.

A documentation string is essentially a string literal written in a function, which must be the first line of code in the body of the function, and may be concatenated in close proximity or with whitespaces, e.g., 'This is a very useful '"function", but it should not contain content or operations that need to be calculated, e.g., 'This is a very useful '+"function", f'It can compute {count} targets'.

When using triple quotes, the documentation string can be multi-line, and any whitespace characters in the string are preserved, but this is only reflected in the __doc__ variable of the function object, and the development tool should handle whitespace characters to present a more user-friendly information to the developer.

# A simple function
def simple(a: int = 1) -> None:
	'''A simple function~~~!

	Sure enough, it's easy.
	'''

Python Nested Functions

A nested function is a function defined in another function or method that uses a syntax that is no different from that of a normal function, and the accessibility of the defined nested function is generally equivalent to that of a variable in the same namespace.

Of course, you can make nested functions callable in more places, by returning values or otherwise, but this defeats the purpose of defining nested functions.

# Sums all numbers less than or equal to 10 in a tuple
def add_list(*l):
	# Nested function check, checks a number, returns 0 if greater than 10
	def check(i):
		return 0 if i > 10 else i


	# Call check to ignore numbers greater than 10 in a tuple
	num = 0
	for i in l:
		num += check(i)


	return num


print(add_list(4, 2, 11, 3))

9

Python Lambda Expressions

Using lambda expressions, you can easily define an anonymous function. Unlike normal functions, functions defined by lambda expressions do not support documentation strings and annotations of parameters or return values, and allow only a single expression whose result is the function’s return value, without the need for a return statement.

# Define an anonymous functions
div = lambda a, b: a / b


print(div(9, 3))

3.0

Source Code

functions.py·codebeatme/python·GitHub