Summer’s over — what’s your move? Join Pro for 50% off using code [MAKEITHAPPEN](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=MAKEITHAPPEN)


A function is a reusable section of code written to perform a specific task in a program. We gave you a taste of functions in Unit 3; here, you'll learn how to create your own.

Functions

After defining a function, it must be *called* to be implemented. In the previous exercise, `spam()` in the last line told the program to look for the function called `spam` and execute the code inside it.

Call and Response

Nice work! Now Python knows how to take the square root of a number.

However, we only really needed the `sqrt` function, and it can be frustrating to have to keep typing `math.sqrt()`.

It's possible to import only certain variables or functions from a given module. Pulling in just a single function from a module is called a *function import*, and it's done with the `from` keyword:

```py
from module import function
```

Now you can just type `sqrt()` to get the square root of a number—no more `math.sqrt()`!

Function Imports

Let's take another look at the definition of the function `square` from the previous exercise:

```py
def square(n):
```

Here, `n` is a _parameter_ of `square`. A parameter is a variable that is an input to a function. It says, "Later, when `square` is used, you'll be able to input any value you want, but for now we'll call that future value n."  A function can have any number of parameters. 

The values of the parameters passed into a function are known as the _arguments_. Recall in the previous example, we called:
```py
square(10)```

Here, the function `square` was called with the parameter `n` set to the argument `10`.

Typically, when you call a function, you should pass in the same number of arguments as there are parameters.

To summarize:

- When defining a function, placeholder variables are called parameters.
- When using, or calling, a function, inputs into the function are called arguments.

Parameters and Arguments

You might have considered the situation where you would like to reuse a piece of code, just with a few different values. Instead of rewriting the whole code, it's much cleaner to define a *function*, which can then be used repeatedly.

What Good are Functions?

Perfect! Last but not least, let's review the built-in functions you've learned about in this lesson.

```py
def is_numeric(num):
  return type(num) == int or type(num) == float:

max(2, 3, 4) # 4
min(2, 3, 4) # 2

abs(2) # 2
abs(-2) # 2
```

Review: Built-In Functions

Functions are defined with three components:

1. The *header*, which includes the `def` keyword, the name of the function, and any *parameters* the function requires. Here's an example:

    ```py
   def hello_world(): # There are no parameters
    ```
2. An optional *comment* that explains what the function does.

    ```py
   """Prints 'Hello World!' to the console."""
    ```
3. The *body*, which describes the procedures the function carries out. The body is *indented*, just like conditional statements.

    ```py
   print "Hello World!"
    ```

Here's the full function pieced together:
```py
def hello_world():
  """Prints 'Hello World!' to the console."""
  print "Hello World!"
```

Function Junction

Now that you understand what functions are and how to *import modules*, let's look at some of the functions that are built in to Python (no modules required!).

You already know about some of the built-in functions we've used with strings, such as `.upper()`, `.lower()`, `str()`, and `len()`. These are great for doing work with strings, but what about something a little more analytic?

On Beyond Strings

Great! We've found a way to handpick the variables and functions we want from modules.

What if we still want all of the variables and functions in a module but don't want to have to constantly type `math.`?

*Universal import* can handle this for you. The syntax for this is:

```py
from module import *
```

Universal Imports

Finally, the `type()` function returns the *type* of the data it receives as an argument. If you ask Python to do the following:

```py
print type(42)
print type(4.2)
print type('spam')
```

Python will output:

```py
<type 'int'>
<type 'float'>
<type 'str'>
```

type()

The `max()` function takes any number of arguments and returns the largest one. ("Largest" can have odd definitions here, so it's best to use `max()` on integers and floats, where the results are straightforward, and not on other objects, like strings.)

For example, `max(1,2,3)` will return `3` (the largest number in the set of arguments).

max()

The `abs()` function returns the **absolute value** of the number it takes as an argument—that is, that number's distance from `0` on an imagined number line. For instance, `3` and `-3` both have the same absolute value: `3`. The `abs()` function always returns a positive value, and unlike `max()` and `min()`, it only takes a single number.

abs()

Good work! Now let's see what you remember about *importing modules* (and, specifically, what's available in the `math` module).

Review: Modules

We've seen functions that can print text or do simple arithmetic, but functions can be much more powerful than that. For example, a function can call another function:

```py
def fun_one(n):
  return n * 5

def fun_two(m):
  return fun_one(m) + 7
```

Functions Calling Functions

Remember `import this` from the first exercise in this course? That was an example of *import*ing a *module*. A module is a file that contains definitions—including variables and functions—that you can use once it is imported.

I Know Kung Fu

Did you see that? Python said: `NameError: name 'sqrt' is not defined.` Python doesn't know what square roots are—yet.

There is a Python module named `math` that includes a number of useful variables and functions, and `sqrt()` is one of those functions. In order to access `math`, all you need is the `import` keyword. When you simply import a module this way, it's called a **generic import**.

Generic Imports

`min()` then returns the smallest of a given series of arguments.

min()

Universal imports may look great on the surface, but they're not a good idea for one very important reason: they fill your program with a *ton* of variable and function names without the safety of those names still being associated with the module(s) they came from.

If you have a function of your very own named `sqrt` and you `import math`, your function is safe: there is your `sqrt` and there is `math.sqrt`. If you do `from math import *`, however, you have a problem: namely, two different functions with the exact same name.

Even if your own definitions don't directly conflict with names from imported modules, if you `import *` from several modules at once, you won't be able to figure out which variable or function came from where.

For these reasons, it's best to stick with either `import module` and type `module.name` or just `import` specific variables and functions from various modules as needed.

Here Be Dragons

Okay! Let's review functions.

```py
def speak(message):
  return message

if happy():
  speak("I'm happy!")
elif sad():
  speak("I'm sad.")
else:
  speak("I don't know what I'm feeling.")
```

Again, the example code above is just there for your reference!
    

Review: Functions

Let's create a few more functions just for good measure.

```py
def shout(phrase):
  if phrase == phrase.upper():
    return "YOU'RE SHOUTING!"
  else:
    return "Can you speak up?"

shout("I'M INTERESTED IN SHOUTING")
```

The example above is just there to help you remember how functions are structured.

Don't forget the colon at the end of your function definition!