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)


Learn how to perform a variety of operations on a list such as - selecting subsections of a list, sorting a list by its values, and much more!

Working with Lists in Python

Now that we know how to create and access list data, we can start to explore additional ways of working with lists.

In this lesson, you'll learn how to:
- Add and remove items from a list using a specific index.
- Create lists with continuous values. 
- Get the length of a list.
- Select portions of a list (called _slicing_).
- Count the number of times that an element appears in a list.
- Sort a list of items.


**Note:** In some of the exercises, we will be using [built-in functions](https://www.codecademy.com/resources/docs/python/built-in-functions?page_req=catalog) in Python. If you haven't yet explored the concept of a function, it may look a bit new. Below we compare it to the method syntax we learned in the earlier lesson.

Here is a preview:  
```py
# Example syntax for methods
list.method(input)

# Example syntax for a built-in function 
builtinfunction(input)
```

.count() is a list method to count the number of occurrences of an element in a list.
.insert() is a list method to insert an element into a specific index of a list.
.pop() is a list method to remove and element from a specific index or from the end of a list. 
range() is a built-in Python function to create sequence of integers. 
len() is a built-in Python function to get the length of a list.
.sort() or sorted() is a method and a built-in function to sort a list.

Working with Lists

In Python, it is common to want to count occurrences of an item in a list. 

Suppose we have a list called `letters` that represents the letters in the word "Mississippi":
```py
letters = ["m", "i", "s", "s", "i", "s", "s", "i", "p", "p", "i"]
```

If we want to know how many times `i` appears in this word, we can use the list method called [`.count()`](https://www.codecademy.com/resources/docs/python/lists/count?page_req=catalog):
```py
num_i = letters.count("i")
print(num_i)
```

Would output:
```bash
4
```
Notice that since `.count()` _returns_ a value, we can assign it to a variable to use it. 

We can even use `.count()` to count element appearances in a two-dimensional list. 

Let's use the list `number_collection`  as an example: 
```py
number_collection = [[100, 200], [100, 200], [475, 29], [34, 34]]
```

If we wanted to know how often the sublist `[100, 200]` appears: 
```py
num_pairs = number_collection.count([100, 200])
print(num_pairs)
```

Would output:
```bash
2
```

Let's count some list items using the `.count()` method! 

Counting in a List

A second way of sorting a list in Python is to use the built-in function `sorted()`.  

The [`sorted()`](https://www.codecademy.com/resources/docs/python/built-in-functions/sorted?page_req=catalog) function is different from the `.sort()` method in two ways:
1. It comes _before_ a list, instead of after as all built-in functions do.
2. It generates a new list rather than modifying the one that already exists. 

Let's return to our list of names:
```py
names = ["Xander", "Buffy", "Angel", "Willow", "Giles"]
```
Using `sorted()`, we can create a new list, called `sorted_names`:
```py
sorted_names = sorted(names)
print(sorted_names)
```
This yields the list sorted alphabetically:
```
['Angel', 'Buffy', 'Giles', 'Willow', 'Xander']
```
Note that using `sorted` did not change `names`:
```py
print(names)
``` 

Would output:
```bash
['Xander', 'Buffy', 'Angel', 'Willow', 'Giles']
```

Sorting Lists II

Often, we'll need to find the number of items in a list, usually called its _length_.

We can do this using a built-in function called [`len()`](https://www.codecademy.com/resources/docs/python/built-in-functions/len?page_ref=catalog).  

When we apply `len()` to a list, we get the number of elements in that list:

```py
my_list = [1, 2, 3, 4, 5]

print(len(my_list))
```

Would output:

```bash
5
```

Let's find the length of various lists! 

Length

The Python list method `.insert()` allows us to add an element to a specific index in a list. 

The [`.insert()`](https://www.codecademy.com/resources/docs/python/lists/insert?page_ref=catalog) method takes in two inputs: 
1. The index you want to insert into. 
2. The element you want to insert at the specified index.

The `.insert()` method will handle shifting over elements and can be used with negative indices. 

To see it in action let's imagine we have a list representing a line at a store: 
```py
store_line = ["Karla", "Maxium", "Martim", "Isabella"]
```

`"Maxium"` saved a spot for his friend `"Vikor"` and we need to adjust the list to add him into the line right behind `"Maxium"`. 

For this example, we can assume that `"Karla"` is the front of the line and the rest of the elements are behind her. 

Here is how we would use the `.insert()` method to insert `"Vikor"` : 

```py
store_line.insert(2, "Vikor")
print(store_line) 
``` 

Would output: 
```bash
 ['Karla', 'Maxium', 'Vikor', 'Martim', 'Isabella']
```
Some important things to note: 

1. The order and number of the inputs is important. The `.insert()` method expects two inputs, the first being a numerical index, followed by any value as the second input. 

2. When we insert an element into a list, all elements from the specified index and up to the last index are shifted one index to the right. This does not apply to inserting an element to the very end of a list as it will simply add an additional index and no other elements will need to shift. 

Let's practice using `.insert()`!


Adding by Index: Insert

Often, we will want to sort a list in either numerical (1, 2, 3, ...) or alphabetical (a, b, c, ...) order.

We can sort a list using the method [`.sort()`](https://www.codecademy.com/resources/docs/python/lists/sort?page_req=catalog).

Suppose that we have a list of names:
```py
names = ["Xander", "Buffy", "Angel", "Willow", "Giles"]
```

Let's see what happens when we apply `.sort()`:
```py
names.sort()
print(names)
```

Would output:
```bash
['Angel', 'Buffy', 'Giles', 'Willow', 'Xander']
```

As we can see, the `.sort()` method sorted our list of `names` in alphabetical order. 

`.sort()` also provides us the option to go in reverse. Instead of sorting in ascending order like we just saw, we can do so in descending order.

```py
names.sort(reverse=True)
print(names)
```

Would output: 
```bash
['Xander', 'Willow', 'Giles', 'Buffy', 'Angel']
```

**Note:** The `.sort()` method does not return any value and thus does not need to be assigned to a variable since it modifies the list directly. If we do assign the result of the method, it would assign the value of `None` to the variable. 


Let's experiment sorting various lists!

Sorting Lists I

Often, we want to create a list of consecutive numbers in our programs. For example, suppose we want a list containing the numbers 0 through 9:
```py
my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
```

Typing out all of those numbers takes time and the more numbers we type, the more likely it is that we have a typo that can cause an error.

Python gives us an easy way of creating these types of lists using a built-in function called [`range()`](https://www.codecademy.com/resources/docs/python/built-in-functions/range?page_req=catalog). 

The function `range()` takes a single input, and generates numbers starting at `0` and ending at the number **before** the input.  

So, if we want the numbers from `0` through `9`, we use `range(10)` because `10` is 1 greater than `9`:
```py
my_range = range(10)
print(my_range)
```

Would output: 
```bash
range(0, 10)
```

Notice something different? The `range()` function is unique in that it creates a _range object_. It is not a typical list like the ones we have been working with. 

In order to use this object as a list, we have to first convert it using another built-in function called [`list()`](https://www.codecademy.com/resources/docs/python/built-in-functions/list?page_ref=catalog).

The `list()` function takes in a single input for the object you want to convert. 

We use the `list()` function on our range object like this:  
```py
print(list(my_range))
```

Would output: 
```bash
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
```

Let's try out using `range()`!

Consecutive Lists: Range

Just as we learned to insert elements at specific indices, Python gives us a method to remove elements at a specific index using a method called `.pop()`. 

The [`.pop()`](https://www.codecademy.com/resources/docs/python/lists/pop?page_req=catalog) method takes an optional single input: 
1. The index for the element you want to remove. 

To see it in action, let's consider a list called `cs_topics` that stores a collection of topics one might study in a computer science program. 
```py
cs_topics = ["Python", "Data Structures", "Balloon Making", "Algorithms", "Clowns 101"]
```

Two of these topics don't look like they belong, let's see how we remove them using `.pop()`. 

First let's remove `"Clowns 101"`: 
```py
removed_element = cs_topics.pop()
print(cs_topics)
print(removed_element)
```

Would output: 
```bash
['Python', 'Data Structures', 'Balloon Making', 'Algorithms']
'Clowns 101'
```

Notice two things about this example: 

1. The method can be called without a specific index. Using `.pop()` without an index will remove whatever the last element of the list is. In our case `"Clowns 101"` gets removed. 

2. `.pop()` is unique in that it will _return_ the value that was removed. If we wanted to know what element was deleted, simply assign a variable to the call of the `.pop()` method. In this case, we assigned it to `removed_element`.


Lastly let's remove `"Balloon Making"`: 
```py
cs_topics.pop(2)
print(cs_topics)
```

Would output: 
```bash
['Python', 'Data Structures', 'Algorithms']
```

Notice two things about this example: 
1. The method can be called with an optional specific index to remove. In our case, the index `2` removes the value of `"Balloon Making"`.
2. We don't have to save the removed value to any variable if we don't care to use it later.

***Note:*** Passing in an index that does not exist or calling `.pop()` on an empty list will both result in an `IndexError`.

Let's apply what we learned about the `.pop()` method.

Removing by Index: Pop

By default, `range()` creates a list starting at `0`.  However, if we call `range()` with two inputs, we can create a list that starts at a different number.  

For example, `range(2, 9)` would generate numbers starting at `2` and ending at `8` (just before `9`):
```py
my_list = range(2, 9)
print(list(my_list))
```
Would output:
```bash
[2, 3, 4, 5, 6, 7, 8]
```

If we use a third input, we can create a list that "skips" numbers. 

For example, `range(2, 9, 2)` will give us a list where each number is `2` greater than the previous number:
```py
my_range2 = range(2, 9, 2)
print(list(my_range2))
```

Would output:
```bash
[2, 4, 6, 8]
```

We can skip as many numbers as we want! 

For example, we'll start at `1` and skip in increments of `10` between each number until we get to `99` (one before `100`):
```py
my_range3 = range(1, 100, 10)
print(list(my_range3))
```
Would output:
```bash
[1, 11, 21, 31, 41, 51, 61, 71, 81, 91]
```

Our list stops at `91` because the next number in the sequence would be `101`, which is greater than or equal to `100` (our stopping point).

Let's experiment with our additional `range()` inputs! 

The Power of Range! 

Slicing syntax in Python is very flexible. Let's look at a few more problems we can tackle with slicing. 

Take the list `fruits` as our example: 
```py
fruits = ["apple", "cherry", "pineapple", "orange", "mango"]
```

If we want to select the *first `n` elements* of a list, we could use the following code:
```py
fruits[:n]
```

For our `fruits` list, suppose we wanted to slice the first three elements. 

The following code would start slicing from index `0` and up to index `3`. Note that the fruit at index `3` (`orange`) is not included in the results.

```py
print(fruits[:3])
```

Would output:
```bash
['apple', 'cherry', 'pineapple']
```

We can do something similar when we want to slice the *last `n` elements* in a list:
```py
fruits[-n:]
```

For our `fruits` list, suppose we wanted to slice the last two elements.

This code slices from the element at index `-2` up through the last index. 
```py
print(fruits[-2:])
```

Would output:
```bash
['orange', 'mango']
```

Negative indices can also accomplish taking *all but n last elements* of a list. 
```py
fruits[:-n]
```

For our `fruits` example, suppose we wanted to slice all but the last element from the list. 

This example starts counting from the `0` index up to the element at index `-1`. 
```py
print(fruits[:-1])
```

Would output:
```bash
['apple', 'cherry', 'pineapple', 'orange']
```

Let's practice some of these extra slicing techniques!

Slicing Lists II

In this lesson, we learned how to:
- Add elements to a list by index using the `.insert()` method.
- Remove elements from a list by index using the `.pop()` method.
- Generate a list using the `range()` function.
- Get the length of a list using the `len()` function.
- Select portions of a list using slicing syntax.
- Count the number of times that an element appears in a list using the `.count()` method.
- Sort a list of items using either the `.sort()` method or `sorted()` function.

As you go through the exercises, feel free to use `print()` to see changes when not explicitly asked to do so. 

Review

In Python, often we want to extract only a portion of a list. Dividing a list in such a manner is referred to as *slicing*. 

Lets assume we have a list of `letters`:
```py
letters = ["a", "b", "c", "d", "e", "f", "g"]
```
Suppose we want to select from `"b"` through `"f"`.

We can do this using the following syntax: `letters[start:end]`, where:
- `start` is the index of the first element that we want to include in our selection.  In this case, we want to start at `"b"`, which has index `1`.
- `end` is the index of _one more than_ the last index that we want to include.  The last element we want is `"f"`, which has index `5`, so `end` needs to be `6`.


```py
sliced_list = letters[1:6]
print(sliced_list)
```

Would output:
```
["b", "c", "d", "e", "f"]
```
Notice that the element at index `6` (which is `"g"`) is *not* included in our selection.