# Difference between revisions of "Function"

 [checked revision] [checked revision]

A canonical function diagram that shows the input, output, and the function body. The name is visible, but the contents (the body) of the function are hidden.

A function is a piece of code that accomplishes a specific task. It usually takes in argument(s) as input, does some processing, and returns a result. Once a function is written, it can be called over and over again.

## Motivation

Functions take advantage of abstraction: we don't care how the function carries out its task, we just care that it gives us a correct result.

In addition, functions allow us to reuse code instead of rewriting it to work with different values.

## Pure function

A pure function produces no effects other than returning a value. Its return value depends only on the inputs. Given the same arguments, it always returns the same value.

### Examples

• `add` always returns the sum of the arguments and has no side effects.
• `square`
```def square(x):
return x * x```
• A `def` statement is used to create the function with intrinsic name square and bind it to the name `square` in the current environment.
• Following the intrinsic name is a list of formal parameters within the parentheses, the names that we will give the arguments to the function in a function call. In this case, we only have one formal parameter `x`.
• Finally, we denote the expression whose value we output as the value of the function call using the `return` statement. In this example, the value of a function call to `square` will be the value of `x * x` evaluated in tho local frame created by that function call.
• If a return statement is not present, a function will automatically output `None`.

## Non-pure function

A non-pure function or impure function produces a side effect (e.g., mutation, printing to screen). Its return value may depend on external state; when called multiple times with the same arguments, it may return different values.

### Examples

#### `print`

The `print` function displays a value on the screen and returns `None`.

#### Functions that modify a variable in another frame

The following `get_a()` function modifies the variable `a` in the global frame:

```a = 0
def get_a():
global a
a += 1
return a - 1```

The following `tick` function modifies the variable `n` in the `countdown` frame:

```def countdown(n):
def tick():
nonlocal n
n -= 1
return n
return tick```

#### Functions that mutate an object in another frame

The following `add_square` function mutates `lst` in the global frame:

```lst = []
def append_square(n):
lst.append(n*n)```

#### `randint`

`randint` returns a random number in the provided range, so the same function call may return different values. Example:

```>>> from random import randint
>>> randint(0, 10)
0
>>> randint(0, 10)
6
>>> randint(0, 10)
7
>>> randint(0, 10)
2
>>> randint(0, 10)
10```

## Higher-order function

Main article: Higher-order function