I like to imagine string just like a banner you might see at a party with each

letter strung together.

That's really what a string is, right?

It's a series of character.

The string data type provides some very handy methods that I'd like you to get

familiar with.

.After you create a string, it cannot be changed.

This is what is known as immutable or impossible to modify.

I'll remind you of this as we look at some of these examples.

Why don't we pop up in a show and I can show you what I'm talking about.

So, string literals, they can be made with either single or double quotes.

And I can imagine that you might say something like this.

You could say, 'I cannot understand why you need two options for quotes'.

Totally understand why you might say something like that.

But that's probably a little bit formal, isn't it?

We should probably use a conjunction.

How about we say something like, 'I can't understand'.

Oops, that's a problem, right?

We've got a quote inside of the quote.

We got a single quote, we are trying to use a single quote, uh-oh.

Now, option is that you can actually make it so

the quote is ignored by doing something called escaping.

So the backslash starts what is known us an escape sequence.

So the backslash, and

then a quote, basically tells the interpreter to treat that quote

like a character instead of treating it like part of the syntax, right?

So if I do, can\ 't understand, now it will see.

But, I mean this is kinda ugly, isn't it?

This backslash t.

Are you glad there's two types of quotes yet?

And actually, look, the REPL fixed it.

So you can use quotes like that.

So if you use double quotes,

then you could very easily use the single quote inside of it, like so.

Now we can say, "I can't", right?

There's a nice string.

And actually, escape sequences are great for

adding blank lines inside of your string.

So there's a special one that you'll see.

If we come over here and we go up, let's get this I can't back here.

Let's say "I can't..., and then we wanna add a new line.

And so that escape sequence to add a new blank line is \n for new line.

So we'd add two, two blank lines and we'll say, I can't even.

And the REPL here is playing tricks on us.

It's trying really hard to keep things on one line for us.

But actually if you print that string; so we'll go ahead and say we'll print.

And then we'll get back the result that was just there, right?

So we use the underscore.

So you'll see that it is actually I can't new line new line even.

There's our new lines.

My wife says that to me all the time while shaking her head about my dad jokes.

You're not the only one.

I suppose, I should quote her though, right?

So I would say, "She said,.

[LAUGH] I can't, so now what?

Now we've got a single quote and a double quote in here.

So actually, triple quotes allow you to start the string.

So we could say, """She said, "I can't...

And the nice thing about triple quotes is it allows you to have

spaces in your string.

So we can press like this and see those triple dots over here.

That means, it's waiting for me to, it's waiting for those final three quotes.

So we can say, "I can't...

even.", so she said that.

And still, there's another quote there, right?

So I'm ending that quote and then it's waiting for three quotes to end it.

So there we go, and if I say, go up a couple times here, we say, print (_).

She said "I can't...

even.", that's what she said.

All right, so now that we got creation out of the way,

let's look at combining some strings together.

What if I had a string like this word, here, chocolate?

Now we can actually combine it together with another string using a plus sign.

So I can say, "chocolate" + "marshmallow".

And you'll see what it returned was a brand new

string with the two words pushed together.

This is called concatenation.

Now, it's important to remember when you're concatenating strings to include

the proper spacing.

Otherwise, it will be slammed together like this.

So what we want is probably more like this,

"chocolate' + " and

marshmallows".

There we go, that feels good.

And of course, we can store that new string that

was created in a variable, right?

So, we could say desert = "chocolate" + " and marshmallows".

So that was a new string created and then we labeled it with dessert.

And we can use that variable to create a brand new one.

This is called reassigning.

So as I dessert = dessert + " and graham crackers".

And now, that might look like we changed the variable dessert.

But what happened was that this statement, dessert + " and

graham crackers", created a new string.

And we removed our already existing label and put it on the new string.

We reassigned it.

The old string, since it didn't have a label,

is essentially thrown away, like those leftovers in my office fridge.

Remember, we didn't actually change the original string because we can't, right?

And that's because strings are immutable.

This appending of more text to the end of a string is pretty common.

So there is a shortcut called in-place addition.

So if we say dessert, we can say +=.

And basically, that's just like the line above.

It's saying dessert = dessert + and then whatever we do.

So we say += ", yum.

And if we take a look, 'chocolate and marshmallows and graham crackers, yum'.

So [LAUGH] that needs some exclamation points, am I right?

And I want some more than just a couple.

I don't wanna just add a whole bunch of them myself.

I'd rather do that in code.

So that's where the asterisk comes into play.

So check this out.

If I want to repeat the string, well,

here's the string, I can then do a * for multiplication.

I say do that 20 times.

Awesome.

In addition to exclamations, this is really handy for

trying to draw layouts in text.

So let's append those.

So we'll say dessert, and we'll do an in-place addition, so dessert,

basically, that's desert +=, and we'll say "!" * 20.

And there we go.

Now before I append some more string information in your brain,

let's take a quick break and return to talk some more about strings.

We'll talk about various handy methods that a string provides.