Preview
Video Player
00:00
00:00
Writing to Files
8:00You often need to write to a file to store data for later use. Python makes this really straightforward!
[MUSIC]
0:00
Hi, I'm Kenneth,
the Python teacher here at Treehouse.
0:04
Quite often, when we're writing code,
0:08
we get the idea that we should
put handy information into files.
0:09
Or just write things out to a file so
we'll have it later.
0:12
I don't mean our scripts, of course.
0:15
Those are saved into files.
0:17
I mean things like, I'm going to ask
the user how they're feeling today,
0:19
and then save it into a file.
0:22
Thankfully, Python makes this easy.
0:24
We only have to know one
function to open the file, and
0:26
a couple of flags to
control how it's opened.
0:28
Let's get over to workspaces
to see how to do this.
0:30
Opening a file in Python
is surprisingly easy.
0:34
But before we can read a file,
we need to write a file, all right?
0:37
I want to write a script that will let me
jot down reminders and notes and such.
0:42
Let's call it remember.py.
0:47
So let's make a new file, remember.py.
0:49
Alright, cool, and let's add in a def
rememberer, and a thing to remember.
0:54
And we'll say open file,
write thing to file, close file.
1:03
And our function has to do something so
we'll just say pass.
1:09
And then let's say if
name is equal to main
1:13
then run rememberer, and
remember should get some input.
1:18
What should I remember?
1:24
So cool,
there's that let's go ahead and run it.
1:28
And what should I remember?
1:33
I don't know remember the milk.
1:34
All right, so that's cool.
1:36
But we actually need to do
the commented things, right?
1:38
So luckily Python gives us this
function that's called open.
1:41
And so we can do like file equals open
1:46
database.txt and
let's just try that, all right?
1:49
So we get the file open and
1:54
we've put it into this pointer,
this variable, called file.
1:56
All right, so let's try running that.
2:01
And you should remember the milk.
2:03
That's a big exception.
2:06
What this exception tells me, is that I
don't have a file named database.txt.
2:08
That's why we get the error.
2:14
We get an error because
the file doesn't exist.
2:15
This a good time to talk about flags.
2:18
Pythons open function uses flags
to tell it how to open the file.
2:20
Like we want to open it for reading,
we want to open it for writing,
2:25
we want to open it for
appending, and other ways.
2:28
By default, if we don't give it an
argument, which is what we've done here.
2:33
Then, it opens it for reading, and reading
kind of requires the file to exist, right?
2:36
Currently, there isn't a database.txt so
Python can't open it.
2:43
So, let's add in the "w" flag.
2:48
W, for write.
2:52
Right?
2:54
So, cool.
2:55
Let's run this again.
2:56
And I want you to remember the milk.
2:58
No errors.
3:00
Great.
3:01
All right, so now, let's see,
let's refresh this over here.
3:01
And when you see that we have
a database.txt, there's nothing in it.
3:06
That's fine, we didn't actually
write anything to the file.
3:09
Let's do that now.
3:13
All right so,
writing the files is really simple.
3:14
We do whatever variable points to
the file and then we do a dot and
3:17
then we do write and then we do whatever
it is we want to write that file.
3:23
So I'm going to do thing and then I'm
gonna add in a new line character.
3:29
That way each thing gets to
be put on to it's own line.
3:35
All right, so let's run that.
3:37
And again, let's say remember the milk.
3:41
And let's go look at database.txt.
3:43
And milk is in there and
there's a new line.
3:46
So, cool, that's pretty neat.
3:49
That's the thing we wanted to be
remembered, and it's in there.
3:51
It's important that we can remember
more than one thing, right.
3:54
So, let's do that.
3:58
And I've already put in milk, so
the other thing I need to remember is,
3:59
I need to remember to get orange juice.
4:03
So, I'm gonna put in orange juice.
4:06
And let's go check and make sure
both those things are in our file.
4:08
Only have orange juice.
4:12
Our old record's gone and
it's been replaced with a new one.
4:13
So, I wonder why that is?
4:18
Let's check the documentation and
let's find out.
4:20
Let's go over here and look for
open and there's open.
4:25
And let's look at these, these are the
modes that I was telling you about.
4:33
So there's R for
reading which is the default.
4:37
There's W for
writing which truncates the file first.
4:39
Aha!
See it truncates.
4:45
Truncates means it deletes
everything out of the file.
4:47
It shortens the file down to 0 bytes.
4:49
There's nothing in the file,
and then it writes.
4:53
Okay, that's not what we want.
4:56
This is why you read the documentation.
4:57
So A opens it,
appends to be in the file if it exists.
5:00
Okay, that's that probably what we want.
5:05
We probably want A.
5:06
And again,
this is why it pays to read the docs.
5:08
Alright, let's fix our script.
5:10
So come over here, we don't wanna open
it with W, we wanna open it with A.
5:12
All right, so right now my database
5:15
file has orange juice in it, so I'm gonna
add milk cuz I still need to get milk.
5:21
All right, so milk and
let's come over here and look at database.
5:24
Sweet, there's orange juice and
there's milk.
5:30
Everything is in there, and
they each have their own line.
5:32
They're all in the file.
5:35
We need to do one more thing,
we need to close the file.
5:37
Now if you're really building this, and
5:41
you're really building it the way that
I'm building it, when this function ends,
5:43
when rememberer hits the end of it and
it's done.
5:46
Then everything inside it
gets garbage collected.
5:50
Python takes all that stuff and goes,
you don't need this anymore, and
5:53
throws it away.
5:56
Which means that the file being open,
the file would be closed.
5:57
So it would be fine, it would be garbage
collected and then it would be closed.
6:01
But, I like being really
explicit about this.
6:06
I don't want to know that
I'm closing the file.
6:08
I want to make sure that file is closed.
6:10
Some I'm gonna do it on purpose.
6:12
So I'm gonna do file.close, not clone,
6:14
close and
I know that the file has been closed.
6:17
So if I run this again, and
6:22
I need to pick up a sweater,
I know the file's been closed.
6:23
Nothing changed outwardly, but Python
opened the file, Python wrote to the file,
6:29
and then Python closed the file.
6:33
This pattern is really,
really common, and it's actually so
6:36
common that there's a built
in easier way to do it.
6:39
We can use the with keyword to make
what's known as a context manager.
6:43
We're defining a block like a if or
a while and inside of that block,
6:48
the variables only exist for
a certain time.
6:54
If I come over here, and I say with, and
6:58
I take out the file equals,
open that as file.
7:03
Now we have, inside here, we have a block.
7:07
Inside this block, the file exists and
the file points to that opened file.
7:09
But once this block ends, file goes away,
which is really awesome and handy.
7:14
So we're actually just going to
indent both of those and since file
7:20
goes away once that with is done,
I don't need those two lines anymore.
7:25
So all I need is,
7:31
open up the file in a context manager,
write the thing into the file.
7:33
So, cool we have two lines that
are replaced our three lines.
7:38
Let's run it one more time
to make sure that it works.
7:41
I remember to get a sword and
7:44
if come look at my database, I have
orange juice, milk, sweater and a sword.
7:47
And it's kinda funny that
orange shows up like that.
7:52
Anyway, so great.
7:55
Now you know how to write to files.
7:56