Learn about strings, their properties, and how to iterate through them to solve many different types of problems.

Introduction to Strings

Words and sentences are fundamental to how we communicate, so it follows that we'd want our computers to be able to work with words and sentences as well. 

In Python, the way we store something like a word, a sentence, or even a whole paragraph is as a [**string**](https://www.codecademy.com/resources/docs/python/strings?page_ref=catalog). A string is a sequence of characters contained within a pair of `'single quotes'` or `"double quotes"`. A string can be any length and can contain any letters, numbers, symbols, and spaces.

In this lesson, we will learn more about strings and how they are treated in Python. We will learn how to slice strings, select specific characters from strings, search strings for characters, iterate through strings, and use strings in conditional statements.

Let's get started.


Now that we are iterating through strings, we can really explore the potential of strings. When we iterate through a string we do _something_ with each character. By including conditional statements inside of these iterations, we can start to do some really cool stuff.

Take a look at the following code:

```py
favorite_fruit = "blueberry"
counter = 0
for character in favorite_fruit:
  if character == "b":
    counter = counter + 1
print(counter)
```

This code will count the number of `b`s in the string "blueberry" (hint: it's two).  Let's take a moment and break down what exactly this code is doing. 

First, we define our string, `favorite_fruit`, and a variable called `counter`, which we set equal to zero. Then the `for` loop will iterate through each character in `favorite_fruit` and compare it to the letter `b`. 

Each time a character equals `b` the code will increase the variable `counter` by one. Then, once all characters have been checked, the code will print the counter, telling us how many `b`s were in "blueberry". This is a great example of how iterating through a string can be used to solve a specific application, in this case counting a certain letter in a word.


Strings and Conditionals (Part One)

So far in this lesson, we've been selecting characters from strings, slicing strings, and concatenating strings. Each time we perform one of these operations we are creating an entirely new string.

This is because strings are _immutable_. This means that we cannot change a string once it is created. We can use it to create other strings, but we cannot change the string itself.

This property, generally, is known as _mutability_. Data types that are _mutable_ can be changed, and data types, like strings, that are _immutable_ cannot be changed.

Strings are Immutable

Great work! I hope you are now starting to see the potential of strings and how they can be used to solve a huge variety of problems.

In this lesson you learned:
- A string is a list of characters.
- A character can be selected from a string using its index `string_name[index]`. These indices start at 0.
- A 'slice' can be selected from a string. These can be between two indices or can be open-ended, selecting all of the string from a point.
- Strings can be concatenated to make larger strings.
- `len()` can be used to determine the number of characters in a string.
- Strings can be iterated through using `for` loops.
- Iterating through strings opens up a huge potential for applications, especially when combined with conditional statements.

Let's put your new skills to the test!


Review

Now you know enough about strings that we can start doing the really fun stuff!

Because strings are lists, that means we can iterate through a string using `for` or `while` loops. This opens up a whole range of possibilities of ways we can manipulate and analyze strings. Let's take a look at an example.

```py
def print_each_letter(word):
  for letter in word:
    print(letter)
```

This code will iterate through each letter in a given word and will print it to the terminal.

```py
favorite_color = "blue"
print_each_letter(favorite_color)
# => 'b'
# => 'l'
# => 'u'
# => 'e'
```

Let's try a couple of problems where we need to iterate through a string.


Iterating through Strings

Python comes with some built-in functions for working with strings. One of the most commonly used of these functions is `len()`. `len()` returns the number of characters in a string:

```py
favorite_fruit = "blueberry"

length = len(favorite_fruit)

print(length)
# Output: 9
```

If you are taking the length of a sentence the spaces are counted as well.

```py
fruit_sentence = "I love blueberries"

print(len(fruit_sentence))
# Output: 18
```

`len()` comes in handy when we are trying to select characters from the end of a string. What is the index of the last character,`"y"`, of `favorite_fruit` from above? You can try to run the following code:

```py
last_char = favorite_fruit[len(favorite_fruit)]

print(last_char)
```

This will result in:

```error
IndexError: string index out of range
```


Why does this generate an `IndexError`? Because the indices start at `0`, so the final character in `favorite_fruit` has an index of `8`. `len(favorite_fruit)` returns `9` and, because there is no value at that index, an `IndexError` occurs. 

Instead, the last character in a string has an index that is `len(string_name) - 1`.

```py
last_char = favorite_fruit[len(favorite_fruit)-1]

print(last_char)
# Output: y
```

You could also slice the last several characters of a string using `len()`:

```py
length = len(favorite_fruit)
last_chars = favorite_fruit[length-4:]
print(last_chars)
# Output: erry
```

Using a `len()` statement as the starting index and omitting the final index lets you slice `n` characters from the end of a string, where `n` is the amount you subtract from `len()`.

More and More String Slicing (How Long is that String?)

In the previous exercise, we used `len()` to get a slice of characters at the end of a string.

There's a much easier way to do this &mdash; we can use negative indices! Negative indices count backward from the end of the string, so `string_name[-1]` is the last character of the string, `string_name[-2]` is the second last character of the string, etc.

Here are some examples:

```py
favorite_fruit = 'blueberry'
print(favorite_fruit[-1])
# => 'y'

print(favorite_fruit[-2])
# => 'r'

print(favorite_fruit[-3:])
# => 'rry'
```

Notice that we are able to slice the last three characters of 'blueberry' by having a starting index of `-3` and omitting a final index.

Negative Indices

We can also _concatenate_, or combine, two existing strings together into a new string. Consider the following two strings:

```py
fruit_prefix = "blue"
fruit_suffix = "berries"
```

We can create a new string by concatenating them together as follows:

```py
favorite_fruit = fruit_prefix + fruit_suffix

print(favorite_fruit)
# Output: blueberries
```

Notice that there are no spaces added here. We have to manually add in the spaces when concatenating strings if we want to include them.

```py
fruit_sentence = "My favorite fruit is" + favorite_fruit

print(fruit_sentence)
# Output: My favorite fruit isblueberries

fruit_sentence = "My favorite fruit is " + favorite_fruit

print(fruit_sentence)
# Output: My favorite fruit is blueberries
```

It's subtle, but notice that in the first example, there is no space between "is" and "blueberries".

Concatenating Strings

A string can be thought of as a [**list**](https://www.codecademy.com/resources/docs/python/lists?page_ref=catalog) of characters.

Like any other list, each character in a string has an index. Consider the string:

```py
favorite_fruit = "blueberry"
```

We can select specific letters from this string using the _index_. Let's look at the first letter of the string.

```py
print(favorite_fruit[1])
# Output: l
```

Whoops, is that the first letter you expected? Notice that the letter at index `1` of `"blueberry"` isn't `b`, it's `l`. This is because the indices of a string start at `0`. `b` is located at the zero index and we could select it using:

```py
print(favorite_fruit[0])
# Output: b
```

It's important to note that indices of strings must be integers. If we were to try to select a non-integer index we would get a `TypeError`.

For example:

```py
print(favorite_fruit[1.5])
```

This would result in:

```error
Traceback (most recent call last):
  File "script.py", line 3, in <module>
    print(favorite_fruit[1.5])
TypeError: string indices must be integers
```


They're all Lists!

Occasionally when working with strings, you'll find that you want to include characters that already have a special meaning in python. For example let's say I create the string

```py
 favorite_fruit_conversation = "He said, "blueberries are my favorite!""
```
We'll have accidentally ended the string before we wanted to by including the `"` character. The way we can do this is by introducing _escape characters_.  By adding a backslash in front of the special character we want to escape, `\"`, we can include it in a string.
```py
favorite_fruit_conversation = "He said, \"blueberries are my favorite!\""
```
Now it works!

Escape Characters

Not only can we select a single character from a string, but we can also select entire chunks of characters from a string. We can do this with the following syntax:

```pseudo
string[first_index:last_index]
```

This is called _slicing_ a string. When we slice a string we are creating a [substring](https://www.codecademy.com/resources/docs/python/substrings?page_ref=catalog) - a brand new string that starts at (and includes) the `first_index` and ends at (but excludes) the `last_index`.

Let's look at some examples of this. Recall our favorite fruit:

```py
favorite_fruit = "blueberry"
```

The indices of this string are shown in the diagram below.

![Blueberry String](https://content.codecademy.com/courses/learn-python-string-methods/string-index.svg)

Let's say we wanted a new string that contains the letters `be`. We could slice `favorite_fruit` as follows:

```py
print(favorite_fruit[4:6])
# Output: be
```

Notice how the character at the first index, `b`, is included, but the character at the last index, `r`, is excluded. If you look for the indices 4 and 6 in the diagram, you can see how the `r` is outside that range.

We can also have open-ended selections. If we remove the first index, the slice starts at the beginning of the string and if we remove the second index the slice continues to the end of the string.

```py
print(favorite_fruit[:4])
# Output: blue

print (favorite_fruit[4:])
# Output: berry
```

Again, notice how the `b` from `berry` is excluded from the first example and included in the second example.

Cut Me a Slice of String

There's an even easier way than iterating through the entire string to determine if a character is in a string. We can do this type of check more efficiently using `in`. `in` checks if one string is part of another string.

Here is what the syntax of `in` looks like:

```py
letter in word
```
Here, `letter in word` is a boolean expression that is `True` if the string `letter` is in the string `word`. Here are some examples:

```py
print("e" in "blueberry")
# => True
print("a" in "blueberry")
# => False
```

In fact, this method is more powerful than the function you wrote in the last exercise because it not only works with letters, but with entire strings as well.

```py
print("blue" in "blueberry")
# => True
print("blue" in "strawberry")
# => False
```

It can be helpful to include more than one boolean expression in the same line of code. To do this, use `and` or `and not` in between the boolean expressions.

```py
print("e" in "blueberry" and "e" in "carrot")
# => False
print("e" in "blueberry" and not "e" in "carrot")
# => True
```
The first example above is `False` because ONE of the expressions was `False`; there is no "e" in "carrot".  The second example is `True` because there is an "e" in "blueberry" and not an "e" in "carrot"; both expressions are `True`.