Lists and dictionaries are powerful tools you can use to store, organize, and manipulate all kinds of information.

Python Lists and Dictionaries

A list index behaves like any other variable name! It can be used to access as well as assign values.

You saw how to access a list index like this:

```py
zoo_animals[0]
# Gets the value "pangolin"
```

You can see how assignment works on line 5:

```py
zoo_animals[2] = "hyena"
# Changes "sloth" to "hyena"
```

New Neighbors

A dictionary is similar to a list, but you access values by looking up a *key* instead of an index. A key can be any string or number.  Dictionaries are enclosed in curly braces, like so:

```py
d = {'key1' : 1, 'key2' : 2, 'key3' : 3}
```

This is a dictionary called `d` with three *key-value pairs*. The key `'key1'` points to the value `1`, `'key2'` to `2`, and so on.

Dictionaries are great for things like phone books (pairing a name with a phone number), login pages (pairing an e-mail address with a  username), and more!

This Next Part is Key

Let's go over a few last notes about *dictionaries*

```py
my_dict = {
  "fish": ["c", "a", "r", "p"],
  "cash": -4483,
  "luck": "good"
}
print my_dict["fish"][0]
```

1. In the example above, we created a dictionary that holds many types of values.
2. The key `"fish"` has a *list*, the key `"cash"` has an *int*, and the key `"luck"` has a *string*.
3. Finally, we print the letter `"c"`. When we access a value in the dictionary like `my_dict["fish"]`, we have direct access to that value (which happens to be a list). We can access the item at index `0` in the list stored by the key `"fish"`.

It's Dangerous to Go Alone! Take This

A list doesn't have to have a fixed length. You can add items to the end of a list any time you like!

```py
letters = ['a', 'b', 'c']
letters.append('d')
print len(letters)
print letters
```

1. In the above example, we first create a list called `letters`.
2. Then, we add the string `'d'` to the end of the `letters` list.
3. Next, we print out `4`, the length of the `letters` list.
4. Finally, we print out `['a', 'b', 'c', 'd']`.

Late Arrivals & List Length

You can access an individual item on the list by its *index*. An index is like an address that identifies the item's place in the list. The index appears directly after the list name, in between brackets, like this: `list_name[index]`.

*List indices begin with 0, not 1!* You access the first item in a list like this: `list_name[0]`.  The second item in a list is at index 1: `list_name[1]`. Computer scientists love to start counting from zero.

Access by Index

Because dictionaries are mutable, they can be changed in many ways. Items can be removed from a dictionary with the `del` command:

```py
del dict_name[key_name]
```

will remove the key `key_name` and its associated value from the dictionary.

A new value can be associated with a key by assigning a value to the key, like so:

```py
dict_name[key] = new_value
```

Changing Your Mind

Like Lists, Dictionaries are *mutable*. This means they can be changed after they are created. One advantage of this is that we can add new *key/value pairs* to the dictionary after it is created like so:
```py
dict_name[new_key] = new_value
```

An empty pair of curly braces `{}` is an empty dictionary, just like an empty pair of `[]` is an empty list.

The length `len()` of a dictionary is the number of key-value pairs it has. Each pair counts only once, even if the value is a list. (That's right: you can put lists *inside* dictionaries!)

New Entries

If you want to do something with every item in the list, you can use a `for` loop. If you've learned about `for` loops in JavaScript, pay close attention! They're different in Python.

```py
for variable in list_name:
  # Do stuff!
```

A variable name follows the `for` keyword; it will be assigned the value of each list item in turn.

Then `in list_name` designates `list_name` as the list the loop will work on. The line ends with a colon (`:`) and the indented code that follows it will be executed once per item in the list.

For One and All

You can slice a string exactly like a list! In fact, you can think of strings as lists of characters: each character is a sequential item in the list, starting from index 0.

```py
my_list[:2]
# Grabs the first two items
my_list[3:]
# Grabs the fourth through last items
```

If your list slice includes the very first or last item in a list (or a string), the index for that item doesn't have to be included.


Slicing Lists and Strings

Sometimes you need to search for an item in a list.

```py
animals = ["ant", "bat", "cat"]
print animals.index("bat")
```

1. First, we create a list called `animals` with three strings.
2. Then, we print the first index that contains the string `"bat"`, which will print `1`.

We can also `insert` items into a list.

```py
animals.insert(1, "dog")
print animals
```

1. We insert `"dog"` at index 1, which moves everything down by 1.
2. We print out `["ant", "dog", "bat", "cat"]`

Maintaining Order

Sometimes you need to remove something from a list.

```py
beatles = ["john","paul","george","ringo","stuart"]
beatles.remove("stuart")
print beatles

```

This code will print:
```py
 ["john","paul","george","ringo"]
```

1. We create a list called `beatles` with 5 strings.
2. Then, we remove the first item from `beatles` that matches the string `"stuart"`. Note that `.remove(item)` does not return anything.
3. Finally, we print out that list just to see that `"stuart"` was actually removed.

Remove a Few Things

Sometimes, you only want to access a portion of a list. Consider the following code:

```py
letters = ['a', 'b', 'c', 'd', 'e']
slice = letters[1:3]
print slice
print letters
```
What is this code doing?

First, we create a list called `letters`.

Then, we take a subsection of the list and store it in the `slice` list. We do this by defining the indices we want to include after the name of the list: `letters[1:3]`.  In Python, when we specify a portion of a list in this manner, we **include** the element with the first index, `1`, but we **exclude** the element with the second index, `3`.

Next, we print out `slice`, which will print `['b','c']`. Remember, in Python indices always start at `0`, so the `1` element is actually `b`.

Finally, we print out `['a', 'b', 'c', 'd', 'e']`, notice that we did not modify the original `letters` list.

List Slicing

If your list is a jumbled mess, you may need to `sort()` it.

```py
animals = ["cat", "ant", "bat"]
animals.sort()

for animal in animals:
  print animal
```

1. First, we create a list called `animals` with three strings. The strings are not in alphabetical order.
2. Then, we sort `animals` into alphabetical order. Note that `.sort()` modifies the list rather than returning a new list.
3. Then, for each item in `animals`, we print that item out as `"ant", "bat", "cat"` on their own line each.

More with 'for'

Lists are a *datatype* you can use to store a collection of different pieces of information as a sequence under a single variable name. (Datatypes you've already learned about include strings, numbers, and booleans.)

You can assign items to a list with an expression of the form 
```py
list_name = [item_1, item_2]
```
with the items in between brackets.  A list can also be empty: `empty_list = []`.

Lists are very similar to strings, but there are a few key differences. 