[MUSIC]

Hi, I'm Kenneth, the Python teacher here at Treehouse.

Quite often, when we're writing code,

we get the idea that we should put handy information into files.

Or just write things out to a file so we'll have it later.

I don't mean our scripts, of course.

Those are saved into files.

I mean things like, I'm going to ask the user how they're feeling today,

and then save it into a file.

Thankfully, Python makes this easy.

We only have to know one function to open the file, and

a couple of flags to control how it's opened.

Let's get over to workspaces to see how to do this.

Opening a file in Python is surprisingly easy.

But before we can read a file, we need to write a file, all right?

I want to write a script that will let me jot down reminders and notes and such.

Let's call it remember.py.

So let's make a new file, remember.py.

Alright, cool, and let's add in a def rememberer, and a thing to remember.

And we'll say open file, write thing to file, close file.

And our function has to do something so we'll just say pass.

And then let's say if name is equal to main

then run rememberer, and remember should get some input.

What should I remember?

So cool, there's that let's go ahead and run it.

And what should I remember?

I don't know remember the milk.

All right, so that's cool.

But we actually need to do the commented things, right?

So luckily Python gives us this function that's called open.

And so we can do like file equals open

database.txt and let's just try that, all right?

So we get the file open and

we've put it into this pointer, this variable, called file.

All right, so let's try running that.

And you should remember the milk.

That's a big exception.

What this exception tells me, is that I don't have a file named database.txt.

That's why we get the error.

We get an error because the file doesn't exist.

This a good time to talk about flags.

Pythons open function uses flags to tell it how to open the file.

Like we want to open it for reading, we want to open it for writing,

we want to open it for appending, and other ways.

By default, if we don't give it an argument, which is what we've done here.

Then, it opens it for reading and reading, kind of requires the file to exist, right?

Currently, there isn't a database.txt so Python can't open it.

So, let's add in the "w" flag.

W, for write.

Right?

So, Cool.

Let's run this again.

And I want you to remember the milk.

No errors.

Great.

All right, so now, let's see, let's refresh this over here.

And when you see that we have a database.txt, there's nothing in it.

That's fine, we didn't actually write anything to the file.

Let's do that now.

All right so, writing the files is really simple.

We do whatever variable points to the file and then we do a dot and

then we do write and then we do whatever it is we want to write that file.

So I'm going to do thing and then I'm gonna add in a new line character.

That way each thing gets to be put on to it's own line.

All right, so let's run that.

And again, let's say remember the milk.

And let's go look at database.txt.

And milk is in there and there's a new line.

So, cool, that's pretty neat.

That's the thing we wanted to be remembered, and it's in there.

It's important that we can remember more than one thing, right.

So, let's do that.

And I've already put in milk, so the other thing I need to remember is,

I need to remember to get orange juice.

So, I'm gonna put in orange juice.

And let's go check and make sure both those things are in our file.

Only have orange juice.

Our old record's gone and it's been replaced with a new one.

So, I wonder why that is?

Let's check the documentation and let's find out.

Let's go over here and look for open and there's open.

And let's look at these, these are the modes that I was telling you about.

So there's R for reading which is the default.

There's W for writing which truncates the file first.

Aha! See it truncates.

Truncates means it deletes everything out of the file.

It shortens the file down to 0 bytes.

There's nothing in the file, and then it writes.

Okay, that's not what we want.

This is why you read the documentation.

So A opens it, appends to be in the file if it exists.

Okay, that's that probably what we want.

We probably want A.

And again, this is why it pays to read the docs.

Alright, let's fix our script.

So come over here, we don't wanna open it with W, we wanna open it with A.

All right, so right now my database

file has orange juice in it, so I'm gonna add milk cuz I still need to get milk.

All right, so milk and let's come over here and look at database.

Sweet, there's orange juice and there's milk.

Everything is in there, and they each have their own line.

They're all in the file.

We need to do one more thing, we need to close the file.

Now if you're really building this, and

you're really building it the way that I'm building it, when this function ends,

when rememberer hits the end of it and it's done.

Then everything inside it gets garbage collected.

Python takes all that stuff and goes, you don't need this anymore, and

throws it away.

Which means that the file being open, the file would be closed.

So it would be fine, it would be garbage collected and then it would be closed.

But, I like being really explicit about this.

I don't want to know that I'm closing the file.

I want to make sure that file is closed.

Some I'm gonna do it on purpose.

So I'm gonna do file.close, not clone,

close and I know that the file has been closed.

So if I run this again, and

I need to pick up a sweater, I know the file's been closed.

Nothing changed outwardly, but Python opened the file, Python wrote to the file,

and then Python closed the file.

This pattern is really, really common, and it's actually so

common that there's a built in easier way to do it.

We can use the with keyword to make what's known as a context manager.

We're defining a block like a if or a while and inside of that block,

the variables only exist for a certain time.

If I come over here, and I say with, and

I take out the file equals, open that as file.

Now we have, inside here, we have a block.

Inside this block, the file exists and the file points to that opened file.

But once this block ends, file goes away, which is really awesome and handy.

So we're actually just going to indent both of those and since file

goes away once that with is done, I don't need those two lines anymore.

So all I need is,

open up the file In a context manager, write the thing into the file.

So, cool we have two lines that are replaced our three lines.

Let's run it one more time to make sure that it works.

I remember to get a sword and

if come look at my database, I have orange juice, milk, sweater and a sword.

And it's kinda funny that orange shows up like that.

Anyway, so great.

Now you know how to write to files.