Function arguments

A function can take arguments and return values:

In the following example, the function say_hello() receives the argument "name" and prints a greeting:

>>> def say_hello(name):
...    print('Hello', name)
...
>>> say_hello('Carlos')
# Hello Carlos

>>> say_hello('Wanda')
# Hello Wanda

>>> say_hello('Rose')
# Hello Rose

The above function does not return any value (implicitly, it returns None) and is called void function. The following function, on the other hand, returns values and is thus called the fruitful function

>>> def my_sum(x,y):
...    "Compute x + y."
...    return x + y
>>> my_sum(1,2)
# 3

Keyword Arguments

When we define functions, we list the input parameters. These are called positional parameters (or positional arguments) because the position in the def statement determines which parameter is which.

>>> def poly(x,y):
...    "Compute x + y**2."
...    return x + y**2
>>> poly(1,2)
# 5
>>> poly(2,1)
# 3

We can set default values for parameters:

>>> def psum(x,y,p=2):
...    return x**p + y**p
>>> psum(1,2)
# 5

To improve code readability, we should be as explicit as possible. We can achieve this in our functions by using Keyword Arguments:

>>> def say_hi(name, greeting):
...    print(greeting, name)
...
>>> # with positional arguments
>>> say_hi('John', 'Hello')
# Hello John

>>> # with keyword arguments
>>> say_hi(name='Anna', greeting='Hi')
# Hi Anna

Return Values

When creating a function using the def statement, you can specify what the return value should be with a return statement. A return statement consists of the following:

• The return keyword.
• The value or expression that the function should return.

>>> def sum_two_numbers(number_1, number_2):
...    return number_1 + number_2
...
>>> result = sum_two_numbers(7, 8)
>>> print(result)
# 15

Args and Kwargs (Optional)

*args and **kwargs allow you to pass an undefined number of arguments and keywords when calling a function.

>>> def some_function(*args, **kwargs):
...     pass
...
>>> # call some_function with any number of arguments
>>> some_function(arg1, arg2, arg3)

>>> # call some_function with any number of keywords
>>> some_function(key1=arg1, key2=arg2, key3=arg3)

>>> # call both, arguments and keywords
>>> some_function(arg, key1=arg1)

>>> # or none
>>> some_function()

:bulb: You’ll often see the parameter name **kwargs used to collect nonspecific keyword arguments. The **kwargs must be the rightmost paramter.

*args

Positional arguments through the *args variable:

>>> def some_function(*args):
...     print(f'Arguments passed: {args} as {type(args)}')
...
>>> some_function('arg1', 'arg2', 'arg3')
# Arguments passed: ('arg1', 'arg2', 'arg3') as <class 'tuple'>

**kwargs

Keyword arguments are accessed through the **kwargs variable:

>>> def some_function(**kwargs):
...     print(f'keywords: {kwargs} as {type(kwargs)}')
...
>>> some_function(key1='arg1', key2='arg2')
# keywords: {'key1': 'arg1', 'key2': 'arg2'} as <class 'dict'>

Local and Global Scope

• Code in the global scope cannot use any local variables.
• However, a local scope can access global variables.
• Code in a function’s local scope cannot use variables in any other local scope.
• You can use the same name for different variables if they are in different scopes. That is, there can be a local variable named spam and a global variable also named spam.

global_variable = 'I am available everywhere'

>>> def some_function():
...     print(global_variable)  # because is global
...     local_variable = "only available within this function"
...     print(local_variable)
...
>>> # the following code will throw error because
>>> # 'local_variable' only exists inside 'some_function'
>>> print(local_variable)
Traceback (most recent call last):
  File "<stdin>", line 10, in <module>
NameError: name 'local_variable' is not defined

The global Statement

If you need to modify a global variable from within a function, use the global statement:

>>> def spam():
...     global eggs
...     eggs = 'spam'
...
>>> eggs = 'global'
>>> spam()
>>> print(eggs)

There are four rules to tell whether a variable is in a local scope or global scope:

1. If a variable is being used in the global scope (that is, outside all functions), then it is always a global variable.
2. If there is a global statement for that variable in a function, it is a global variable.
3. Otherwise, if the variable is used in an assignment statement in the function, it is a local variable.
4. But if the variable is not used in an assignment statement, it is a global variable.

Importing a module

To start importing functions, we first need to create a module. A module is a file ending in .py that contains the code you want to import into your program. Let’s consider a module that contains the function make_pizza().

Direct import

import pizza

pizza.make_pizza(16, 'pepperoni')
pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

Importing Specific Functions using from

from pizza import make_pizza

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

Using as to Give a Function or Module an Alias

from pizza import make_pizza as mp

mp(16, 'pepperoni')
mp(12, 'mushrooms', 'green peppers', 'extra cheese')

Importing All Functions in a Module

from pizza import *

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

:bulb: However, it’s best not to use this approach when you’re working with larger modules that you didn’t write: if the module has a function name that matches an existing name in your project, you can get unexpected results!

Keywords

• divide and conquer (分治法): A strategy that breaks a problem into smaller, manageable subproblems, solves each independently, and then combines the results.
• abstraction (抽象化): The concept of hiding complex details and showing only the essential features of a process.
• function (函數): A reusable block of code designed to perform a specific task when called.
• function call (函數呼叫): The act of executing a function by specifying its name along with any required arguments.
• argument (引數): The actual value or variable passed to a function when it is called.
• parameter (參數): A variable in a function definition that receives the value of an argument when the function is called.
• positional argument (位置參數): An argument that must be passed to a function in the correct order as defined by its parameters.
• docstring (文件字串): A string placed at the beginning of a function or module to describe its purpose and usage.
• return statement (回傳敘述): A statement that ends a function's execution and optionally passes back a value to the caller.
• fruitful function (有回傳值的函數): A function that returns a value after execution.
• void function (無回傳值的函數): A function that does not return any value.
• keyword argument (關鍵字參數): An argument passed to a function by explicitly naming the parameter, allowing arguments to be specified in any order.
• default parameter (預設參數): A parameter that has a pre-assigned value, which is used if no argument is provided during the function call.
• local scope (區域): The region of a program (typically within a function) where a variable is defined and accessible only within that block.
• global scope (全域): The region of a program where variables are accessible from any part of the code, usually defined outside of functions.
• local variable (區域變數): A variable defined inside a function that can only be used within that function.
• global variable (全域變數): A variable defined at the top level of a module that can be accessed from anywhere within that module.
• module (模組): A file containing Python code, such as functions, classes, or variables, that can be imported and reused in other Python programs.