This lesson will introduce you to strings and console output in Python, including creating string literals, calling a variety of string methods, and using the "print" keyword.

Strings & Console Output

Now let's look at `str()`, which is a little less straightforward. The `str()` method turns non-strings into strings! For example:

```py
str(2)
```

would turn `2` into `"2"`.

str()

Great work! Now that we know how to store strings, let's see how we can change them using **string methods**.

**String methods** let you perform specific tasks for strings.

We'll focus on four string methods:

1. `len()`
2. `lower()`
3. `upper()`
4. `str()`

Let's start with `len()`, which gets the length (the number of characters) of a string!

String methods

Excellent! Let's get a little practice in with strings.

Practice

Great! Now that we've printed strings, let's print variables

Printing Variables

There are some characters that cause problems. For example:

```py
'There's a snake in my boot!'
```

This code breaks because Python thinks the apostrophe in `'There's'` ends the string. We can use the backslash to fix the problem, like this:

```py
'There\'s a snake in my boot!'
```

Escaping characters

Well done!

You can use the `lower()` method to get rid of all the capitalization in your strings. You call `lower()` like so:

```py
"Ryan".lower()
```

which will return `"ryan"`.

lower()

The area where we've been writing our code is called the **editor**.

The **console** (the window to the right of the editor) is where the results of your code is shown.

`print` simply displays your code in the console.



Printing Strings

When you want to print a variable with a string, there is a better method than concatenating strings together.

```py
name = "Mike"
print "Hello %s" % (name)
```

The `%` operator after the string is used to combine a string with variables. The `%` operator will replace the `%s` in the string with the string variable that comes after it.

If you'd like to print a variable that is an integer, you can "pad" it with zeros using `%02d`. The `0` means "pad with zeros", the `2` means to pad to 2 characters wide, and the `d` means the number is a signed integer (can be positive or negative).

```py
day = 6
print "03 - %s - 2019" %  (day)
# 03 - 6 - 2019
print "03 - %02d - 2019" % (day)
# 03 - 06 - 2019
```

String Formatting with %, Part 1

Now your string is 100% lower case! A similar method exists to make a string completely upper case.

upper()

Another useful data type is the **string**. A **string** can contain letters, numbers, and symbols.

```py
name = "Ryan"
age = "19"
food = "cheese"
```

1. In the above example, we create a variable `name` and set it to the string value `"Ryan"`.
2. We also set `age` to `"19"` and `food` to `"cheese"`.

Strings need to be within quotes.

Strings

You know about strings, and you know about arithmetic operators. Now let's combine the two!

```py
print "Life " + "of " + "Brian"
```

This will print out the phrase `Life of Brian`.

The `+` operator between strings will 'add' them together, one after the other. Notice that there are spaces inside the quotation marks after `Life ` and `of ` so that we can make the combined string look like 3 words.

Combining strings together like this is called **concatenation**. Let's try concatenating a few strings together now!

String Concatenation

Let's take a closer look at why you use `len(string)` and `str(object)`, but dot notation (such as `"String".upper()`) for the rest.

```py
lion = "roar"
len(lion)
lion.upper()
```

Methods that use dot notation only work with strings.

On the other hand, `len()` and `str()` can work on other data types.

Dot Notation

Great job! You've learned a lot in this unit, including:

Three ways to create strings
```py
'Alpha'
"Bravo"
str(3)
```

String methods

```py
len("Charlie")
"Delta".upper()
"Echo".lower()
```

Printing a string

```py
print "Foxtrot"
```

Advanced printing techniques

```py
g = "Golf"
h = "Hotel"
print "%s, %s" % (g, h)
```


And Now, For Something Completely Familiar

Remember, we used the `%` operator to replace the `%s` placeholders with the variables in parentheses.

```py
name = "Mike"
print "Hello %s" % (name)
```

You need the same number of `%s` terms in a string as the number of variables in parentheses:

```py
print "The %s who %s %s!" % ("Knights", "say", "Ni")
# This will print "The Knights who say Ni!"
```

String Formatting with %, Part 2

Sometimes you need to combine a string with something that isn't a string. In order to do that, you have to convert the non-string into a string.

```py
print "I have " + str(2) + " coconuts!"
```

This will print `I have 2 coconuts!`.

The `str()` method converts non-strings into strings. In the above example, you convert the number `2` into a string and then you concatenate the strings together just like in the previous exercise.

Now try it yourself!

Explicit String Conversion

Great work!

Each character in a string is assigned a number. This number is called the **index**. Check out the diagram in the editor.

```py
c = "cats"[0]
n = "Ryan"[3]
```

1. In the above example, we create a new variable called `c` and set it to `"c"`, the character at index zero of the string `"cats"`.
2. Next, we create a new variable called `n` and set it to `"n"`, the character at index three of the string `"Ryan"`.

Notice that in the first "cat" example we are calling the 0th letter of "cat" and getting "c" in return. This is because in Python indices begin counting at 0. Therefore, in the string "cats", the first letter,  "c", is at the 0th index and the last letter, "s", is at the 3rd index.