All right, so we wanna come up with a handy function that

will allow us to display each wish list in a standard sort of fashion.

This is, as you know, a wonderful place to use a function.

So we want to display our heading, just like we did here like we say this, books.

And we also wanna display our list so we're gonna loop through list.

So we got this, right?

Let's make a new function.

So the function will look like, let's see,

we're gonna define the new function called display wish list.

And first we want to know what that heading is.

Let's call that display_name.

So that'll be books or video games.

And then the items that we want.

So we'll just pass in wishes cuz it's a wish whether it's a book or

it's a video game list.

This is the list of there that we're gonna pass it.

Awesome.

So first we'll just print out that header.

So we''ll say display_name and

we'll make that a colon.

There we go You know what, let's go ahead, let's do this suggested gift thing.

Let's go ahead and put this as part of our function.

Cause we'll suggest a gift from each one of them.

So, hm, you know what I was just thinking?

If we show a suggested gift from the list,

we shouldn't show it in the other part, right?

So I guess what we want to do is we just wanna pop that first one off, right?

I mean, what could go wrong?

So we'll say suggested_gift equals wishes.pop.

And we'll get the first one right?

So we want pop zero.

Okay, so let's make this stand out a little bit.

We'll say print, we'll add some arrows here at the front.

Let's really stand out and we'll print out that suggested_gift.

And we're removed that from the list.

So we can probably just do what we did before.

So we just wanna loop through each of the wishes.

So we can say, for wish in wishes and we will print.

Let's see so we used the star before for bullet, plus wish, there we go,

and then at the very end let's just add a blank print here

after the display wish list, so that will keep things separate.

Cool, so now we should be able to just call that function.

So we'll say display_wishlist and

we will call that for the display name is books.

And there that wish, the list of wishes we have that's called books.

And let's do it for video games.

So I can just copy this.

And instead of books,

we have video games.

Awesom, that feel pretty clean, right?

Let's git rid of these other things Here.

There you go.

Yeah nice and clean.

So we've got the two lists,

we have a function, we're gonna call it let's see what it looks like.

So we'll say python Awesome, looks like we go it.

I'm gonna scroll this up a little bit and run that again.

Sometimes the scrolling gets a little wacky here.

Cool, so we've pulled one off and we pulled the second one off.

And it looks right, looks good, right?

There's a little bug in our program though.

Let's take a look.

Do you see what that bug is?

Here, this'll really demonstrate it.

Let's do this, I'm gonna go ahead, I'm gonna call this again one more time.

That's weird.

The second time through, it's a little bit shorter and it's a different suggestion.

That's because we're changing the list with that pop command.

This pop command here is actually changing this list.

Now, I made that happen on purpose to really highlight

the caution that you should take when dealing with mutable objects.

So let's think about how a user of this function might feel.

They pass their list in here to get a function called display wishlist and

I'm pretty sure that they aren't gonna expect their list to get an an item

removed from it.

That's gonna come as a shock.

So remember, these parameters can be thought of like applying the label,

display name equals books and wishes equals books.

So we've applied a label to that object that was passed in.

Now, the label only lasts while the function is running and then it's removed.

But during that function execution, the label,

wishes, it's referring to the same object.

Now in this case, it was the video games list.

That's why when we call pop, it changes the object because it's the same object.

So there are better ways to do this.

One rule to follow is to not modify someone else's objects

unless you are explicit about it in your method name.

If you find yourself needing to change a list, like we did here just for

display purposes, you can use the copy method.

The copy method on lists allows you to make a copy of the list and

this leaves the previous one intact.

So let's go ahead and do that.

So I'm going to make a new copy of the list when we come in here and

I'm gonna call it items.

So items equals wishes.copy.

Not.copy and then instead of wishes here, I'm gonna say items.

And then we can say for item and

items, item.

So items is now a completely unrelated copy of wishes.

Now, I can change items all I want and it won't change this, just a copy.

So here watch, we'll run it again and you'll see both of them.

It stayed the same each time.

It didn't change that master video games list.

Now I should point out that you could actually solve this problem that we're

having here by not removing the element from the list at all.

And only iterating through the lists starting at the second element.

You could use what is known as a slice.

We'll get to that here in a bit, and check the teacher's notes for a sneak peek.

Another thing that I want you to be careful of is loops, and mutability.

So let's pop open a repel really quick.

Let's pop open, we'll say python

Let's take an example from one of those video games I was playing.

Let's use Zelda.

It's an adventure game, and you collect items, and

you keep them in your inventory.

So a typical inventory might look something like this.

So we have inventory, do a list and you might have a shield,

definitely have apples that's how you go ahead and eat things.

And then you have a sword, maybe you'll have a bow like for a bow and arrow,

a boomerang.

All right, basic inventory from an adventure game, right?

So one thing that we haven't looked at yet

is that you can remove an element from a list by value.

So you could say inventory.

And there is a method called remove and

let's say that we wanted to get rid of that apple.

So we're gonna remove the apple from our inventory and

now if you look at inventory, you'll see that it's gone.

A common problem that happens is that you mutate the list

while you're looping over it.

Like for instance,

let's say that you wanted to drop everything from your inventory.

You might think that you could do something like this, for item

in inventory, so we're just gonna loop though every single one of these items.

And, we'll say, inventory.remove, and we are going to remove that item.

That seems like it make sense, right?

But we were looping over it, so what happens is you get this weird

unexpected result, you still got a sword and a boomerang left.

So again, this is where copy saves the day.

You just loop over a copy of the array, like so.

Let's do this. So let's come up here.

Let's reset our inventory.

Here we go and for an inventory.copy, so we'll loop through each one of those and

then we'll choose, I'm using the up arrow here.

We'll remove from the master list.

So this will create a new list, we're not gonna assign it to a variable,

it's just gonna create a new one and it's gonna loop through that.

But we're gonna remove from the actual inventory list.

Now if we take a look, bam.

So just remember to be extra thoughtful when dealing with mutable objects.

After a quick break let's head back and I wanna show off some pretty great string

methods that are gonna help dealing with iterables like our list.