[MUSIC]

While it might not seem like a problem,

one of the biggest drawbacks to lists is that they're mutable or editable.

Why is mutability a problem?

Most of the time, it's not.

You can go a long way with lists and their flexible data.

Sometimes though,

it's really important that our data stay exactly how we created it.

It has to stay in exactly the same order.

And each member should keep its value.

That's where tuples come in.

Or tuples.

Honestly, I'm not sure which is the right way.

But I like tuples.

So that's what I'm going to say.

Tuples are like lists in that each member has an index.

They can be looped over.

And each member can be pretty much any other data type that you want to use.

Tuples, though, can't be changed in place.

They're immutable.

This also makes them a bit more memory efficient, which is always nice win.

All right, time for tuples in work spaces.

One of the first really interesting and

different things about tuples is how they're constructed.

We make lists with brackets.

All right?

And commas.

Or well, brackets and commas.

We make dictionaries with braces and colons.

And strings, you make with quote marks, double or single.

Most of the time,

you'll see people creating tuples with parentheses and commas.

So you'll see like, my_tuple = {1,2,3}.

And I look at my tuple.

It's a tuple, right?

And has parenthesis.

And if you ask a random Python user if the parenthesis make the tuple.

There is an all right chance that they're going to say yes.

Because you almost always see them with parentheses.

But really it's the comma that makes it a tuple.

See, check this out.

I do my second tuple equals one comma to comma three.

And then I look at my second tuple.

Still 1, 2, 3. Now this is also why we have

to include a comma.

When I make a tuple with just a single item.

Otherwise, we get whatever item we wanted to put in the tuple.

Right. If I do my_third_tuple.

And I did (5).

If I look at my_third_tuple, I just get the number 5.

This was because Python lets you use parentheses to mark something as a single

bit of data, even if it takes up multiple lines.

Try this with a string gets really handy, but let's go back to tuples.

For instance, if I want this one to actually be a tuple,

I have to put a comma in there.

And now, my third tuple is actually a tuple.

So feel free to create your tuples either way, with parenthesis or without.

Often, the parenthesis make your tuples more obvious, so they're a good idea.

Just like with lists and strings, we can make tuples with the tuple function too.

So, my fourth tuple = tuple, and

then I'll put in a list of (1, 2, 3).

And, now my fourth tuple is the tuple (1, 2, 3).

Now I said that tuples are immutable.

Just to test, let's try and change one of the numbers in our tuples.

So, my tuples 0 is = to 5.

And, I get a type error.

Because tuple object does not support item assignment.

So cool, okay.

And I get the same thing if I try to do my_tuple[0] += 2,

because it doesn't support item assignment.

So, okay, can't assign things to specific indexes of a tuple.

And if we do dir on a tuple, so I'll do dir(my_tuple).

Then we can see that we don't have nearly as many ways to change them as lists do.

So okay.

There's all of our stuff that we can do.

Now, we can count tuples and find the index of a member, right.

We can count them, we can find the index of something.

But we can't add items.

We can't pop items off.

And we can't even call del on our tuples.

One fun little gotcha with tuples though,

is that you can change the values inside of mutable tuple members.

That's a lot of jargon, so let me just show you.

So let's make tuple with a list.

And it's going to be one.

And then the string apple.

And then a list of three four and five.

And if I look at couple with a list.

I see those items.

Right? So,

if I try to change immutable objects inside the tuple.

Well, you can guess what happens here.

Tuple with a list zero equals five, we've already done this.

Right? We get item assignment.

Which is correct.

Because numbers are immutable.

I get the same result if I try to change, say, number one which is currently apple.

If I want to change that to banana.

Then I get my type error again.

Because strings are immutable, right.

But lists are mutable.

So tuple with a list.

And let's try to change two and one.

And I want to make that a seven.

So now if I look at tuple with a list.

I have three seven five.

Instead of three four five, so... awesome.

The only thing that I can't do is actually remove that list.

Because that would be changing the tuple.

I can do whatever I want to the inside of the list, though.

So tuples seem to be heavily restricted lists.

Why would you want to use them?

Tuples have a fixed size and

memory, which is great if you want to reduce the memory footprint of a script.

But they also have a couple of surprising uses for swapping values around.

And they're great for packing and unpacking.

Let's check those out in our next video.