So I've changed the script a little bit.

I've imported sys which I'm using down here.

I'll talk about what argv does in just a minute.

And I've added this function called show.

This is what we are going to use to print out the things that we've saved.

What is sys.argv?

Sys.argv is all of the arguments after your filename.

So if I do python remember.py, and I pass in and

juice boxes that's a common shopping thing for

me, and I come over here to the database, we'll see juice boxes added in.

Juice boxes here is what's in argv.

This is argv zero.

This is argv one.

And this is argv two and so on.

So, when I do this space.join.sys.argv.1:

that grabs everything after remember.py and joins it together with the space.

So that's how we can take all those words.

What I'm doing is I'm checking to see if the first word is --list.

And if it is, then I want to run this show function.

But show currently doesn't do anything.

So let's fill that out, make it do stuff.

All right, so we've already talked about how to use a context manager.

So let's do that.

So we'll say with open("database.txt",

and now I can do r but that's the default so if I don't specify it, it still does r.

And, we'll call if file, and

then inside of here we wanna print out all the stuff that's in the file.

We just have the file open.

So, how do we print out everything that's in that file?

Well, the cool this is, Python treats files kind of like they are iterables.

They are iterables, but it treats them like they're a list or something.

So I can do for line in file: print(line) all right,

and I don't need to close the file because the context processor handles that for me.

So let's save that and so lets do python remember.py --list.

And check that out, there's all of our stuff.

Let's run this one more time.

There we go, there's our stuff that we wanted to get.

Orange Juice, milk, a sweater, a sword, and juice boxes.

I'm hopeful I can go to a store that has all of those things at once.

So cool.

There's all of our stuff.

I have two other methods that I can use to control how stuff is read though.

Instead of writing these into our file, let's just play with them in the terminal.

So I'm gonna actually slide that most of the way up, and I'm gonna clear, and

I'm gonna go into Python.

So, I have a file that has all the teachers in it, it's called teachers.txt.

And I'm gonna mess with that one.

So I'm gonna open it up.

open('teachers.txt').

I could pass in the r flag for reading it, but

I don't need to do that because it's read by default.

And let's do file.read(10).

I wanna read 10 bytes of this file.

And the 10 is the number of bytes and I get Nick Petti, so, cool new name, Nick.

And so, the cool thing is that this lets me just read parts of a file.

If I know that I can only process, say, 1,024 bytes at a time,

then I can read in just 1,024 bytes at a time.

So, that's pretty cool.

It's pretty handy.

And you can read the entire file if you want,

by doing it with no argument or with a negative number.

If we do file.read, we get the rest of the file and it's the rest of the file because

here's the t that should have been on Nick's name.

It's not because when you have a file object in Python,

there is a little argument, a little value, on that file object.

That's a pointer to where we've read to in the file.

We know how much we read up to.

So we know that we've read 10 bytes.

So when we say, okay, keep reading that file,

it starts at the 11th byte and keeps moving.

The way that we reset that, is we can use file.seek.

And if we just do file.seek it has to have an argument so

we tell it where to go and we say go back to 0.

And it gives us back where it currently is.

It's currently at 0.

All right, so that's cool.

And then you do file.read(15) and we've got the 11 characters of Nick's name,

the one new line character, and then three characters of Amit's name.

That adds up to 15 bytes total.

All right, that's really handy.

I want to show you one last thing about reading from files though.

Let's go back to the beginning and lots of times we have a file and

it has a whole lot of lines in it and each line needs to be a thing on its own.

So, the way that we can do that is by using the read-lines method.

There's also a read-line method, which would just read one line.

But read-lines is way more useful.

So let's do lines=file.readlines and then let's look at the len of the lines.

So cool, it says there's 17 things in there.

All right, let's look at our teachers.txt and yep, there are 17 lines.

And the cool thing is we could do like, for line in lines:

print(line[::-1]).

And there's everybody's names backwards.

So that's kind of cool.

There's lots of other things you can do with files so go and explore them.

Using files for storing data is a really handy thing for

a lot of programming problems.

It's also a great way to get output from a script

if you need the script to run in the background or something like that.

You might want to use the logging library for that though, so

be sure to check it out before jumping straight to writing to files yourself.

If you're working with files, there's a good chance you're going to need to use

CRV or JSON files or some other format.

Keep an eye out for another workshop about both of those file formats.

As always, if you have an idea for future workshops, let me know.

Thanks for watching and I'll see you soon