# Defining Our Own Functions#

Sometimes we’ll have a calculation we want to do over and over again. For example, the sum of squares of numbers is a common and important metric in statistics, geometry, and elsewhere. (For example, Euclidean distance is the square root of the sum of squares.) We could repeatedly write out the arithmetic each time we needed it:

```num1 = ...
num2 = ...
num3 = ...
num4 = ...
answer1 = num1 * num1 + num2 * num2
answer2 = num3 * num3 + num4 * num4
...
```

Writing it out like this is fine for short calculations, but longer ones (like, say, calculating the Euclidean distance between two points, or a more complicated statistical measure), are tedious and error-prone to type out repeatedly. Even copy-pasting isn’t that great, because it’s easy to make errors when renaming the variables. If you find a bug in one version, you have to find all of the copy-pasted versions and fix those, too! Copy-pasting code is generally not a great idea.

This motivates a crucial and fundamental programming idea, which is writing our own function definitions.

We can write our own function that returns the sum of squares of two numbers:

```def sum_of_squares(n1, n2):
return n1 * n1 + n2 * n2
```

Here, we say that

• `sum_of_squares` is the funciton name

• `n1` and `n2` are the parameters or argument names or the formal arguments of the function

• `return n1 * n1 + n2 * n2` is the body of the function

In addition, return and def are examples of keywords. They are part of the Python language and have special meaning as part of function definitions. def tells Python that this line (and potentially the next few lines) will describe a function. return tells Python to evaluate the expression after it and make that be the result of the current function call – we’ll describe that in a minute.

It’s also required that all the lines that are part of the function body be indented (in this case by 2 spaces). If there’s more than one line, they must be indented the same amount (with some important exceptions we’ll see in later chapters).

If we run this module and interact with it, we can call the `sum_of_squares` function just like we could call `max` or `abs`:

```>>> sum_of_squares(4, 5)
41
>>> sum_of_squares(1, 2)
5
```

We can describe how a call to `sum_of_squares` works as follows.

To evaluate `sum_of_squares(4, 5)`, Python:

• evaluates the body of the `sum_of_squares` function,

• substituting the values of the actual arguments (4 and 5) for the formal arguments (`n1` and `n2`)

• when the expression after the `return` has the final value, that value is the value of the whole function call

So we could think of evaluation taking these steps:

```sum_of_squares(4, 5)
-> return 4 * 4 + 5 * 5
-> return 16 + 25
-> return 41
-> 41
```

The first step is where the argument values are substituted for `n1` and `n2`. Then we do some arithmetic as usual, and then the final value, 41, is the result of the function call.

We can define functions that work with strings (and any other datatype we see in the future), too. For example, we could write a function that fills in a sentence:

```def fill_in(adjective, noun):
return "The " + adjective + " " + noun + " wasn't very inspired."
```

Let’s run it:

```>>> fill_in("first", "example")
"The first example wasn't very inspired."
>>> fill_in("third", "sequel")
"The third sequel wasn't very inspired."
```

In both of these cases, we can see the same rules as before: The function call takes the argument values (like `"third"` and `"sequel"`), and uses them for the values of the parameters (the variables `adjective` and `noun`). Then the result of the whole function call expression is the result of the expression after `return`.