Now that you've learned about lists, let's turbo-charge them with functions.

Lists and Functions

You pass a list to a function the same way you pass any other argument to a function.

Passing a list to a function

Okay! Range time. The Python `range()` function is just a shortcut for generating a list, so you can use ranges in all the same places you can use lists.

```py
range(6) # => [0, 1, 2, 3, 4, 5]
range(1, 6) # => [1, 2, 3, 4, 5]
range(1, 6, 3) # => [1, 4]
```

The `range` function has three different versions:

1. `range(stop)`
2. `range(start, stop)`
3. `range(start, stop, step)`

In all cases, the `range()` function returns a list of numbers from `start` up to (but not including) `stop`. Each item increases by `step`.

If omitted, `start` defaults to `0` and `step` defaults to `1`.

Passing a range into a function

Using multiple lists in a function is no different from just using multiple arguments in a function!

```py
a = [1, 2, 3]
b = [4, 5, 6]
print a + b
# prints [1, 2, 3, 4, 5, 6]
```

The example above is just a reminder of how to concatenate two lists.

Using two lists as two arguments in a function

You've already learned how to modify elements of a list in a previous section. This exercise is just a recap of that!

List element modification

This exercise will expand on ways to remove items from a list. You actually have a few options. For a list called `n`:

1.  `n.pop(index)` will remove the item at `index` from the list and return it to you:
```py
n = [1, 3, 5]
n.pop(1)
# Returns 3 (the item at index 1)
print n
# prints [1, 5]
```

2.  `n.remove(item)` will remove the actual `item` if it finds it:
```py
n.remove(1)
# Removes 1 from the list,
# NOT the item at index 1
print n
# prints [3, 5]
```

3.  `del(n[1])` is like `.pop` in that it will remove the item at the given index, but it won't return it:
```py
del(n[1])
# Doesn't return anything
print n
# prints [1, 5]
```

Removing elements from lists

You can also append or delete items of a list inside a function just as if you were manipulating the list outside a function.

```py
my_list = [1, 2, 3]
my_list.append(4)
print my_list
# prints [1, 2, 3, 4]
```

The example above is just a reminder of how to append items to a list.

List manipulation in functions

Now let's try working with strings!

```py
for item in list:
  print item

for i in range(len(list)):
  print list[i]
```

The example above is just a reminder of the two methods for iterating over a list.

Using strings in lists in functions

This exercise will recap how to use more than one argument in a function.

More than one argument

Now that we've learned about `range`, we have two ways of iterating through a list.

**Method 1** - `for item in list`:

```py
for item in list:
  print item
```

**Method 2** - iterate through indexes:

```py
for i in range(len(list)):
  print list[i]
```

Method 1 is useful to loop through the list, but it's not possible to modify the list this way.

Method 2 uses indexes to loop through the list, making it possible to also modify the list if needed. Since we aren't modifying the list, feel free to use either one on this lesson! 

Iterating over a list in a function

This exercise shows how to modify each element in a list. It is useful to do so in a function as you can easily put in a list of any length and get the same functionality. As you can see, `len(n)` is the length of the list.

Modifying each element in a list in a function

In this exercise, you will just be making a minor change to a function to change what that function does.

Changing the functionality of a function

Passing a list to a function will store it in the argument (just like with a string or a number!)

```py
def first_item(items):
  print items[0]

numbers = [2, 7, 9]
first_item(numbers)
```

1. In the example above, we define a function called `first_item`. It has one argument called `items`.
2. Inside the function, we `print` out the item stored at index zero of `items`.
3. After the function, we create a new list called `numbers`.
4. Finally, we call the `first_item` function with `numbers` as its argument, which prints out `2`.

Using an element from a list in a function

Modifying an element in a list in a function is the same as if you were just modifying an element of a list outside a function.

```py
def double_first(n):
  n[0] = n[0] * 2

numbers = [1, 2, 3, 4]
double_first(numbers)
print numbers
```

1. We create a list called `numbers`.
2. We use the `double_first` function to modify that list.
3. Finally, we print out `[2, 2, 3, 4]`

When we pass a list to a function and modify that list, like in the `double_first` function above, we end up modifying the original list.


Modifying an element of a list in a function

This exercise will go over how to utilize every element in a list in a function. You can use the existing code to complete the exercise and see how running this operation inside a function isn't much different from running this operation outside a function.

Don't worry about the `range` function quite yet—we'll explain it later in this section.

Printing out a list item by item in a function

This exercise goes over just pulling information from a list, which we've covered in a previous section!

List accessing

Finally, this exercise shows how to make use of a single list that contains multiple lists and how to use them in a function.

```py
list_of_lists = [[1, 2, 3], [4, 5, 6]]

for lst in list_of_lists:
  for item in lst:
    print item
```

1. In the example above, we first create a list  containing two items, each of which is a list of numbers.
2. Then, we iterate through our outer list.
3. For each of the two inner lists (as `lst`), we iterate through the numbers (as `item`) and print them out.

We end up printing out:

```py
1
2
3
4
5
6
```

Using a list of lists in a function

This is a basic recap on using strings in functions.

Strings in functions

Here, we'll quickly recap how to `.append()` elements to the end of a list.