One of the benefits that directories give us is a logical grouping of files.

We can keep all of our cat photos,

project files or favorite rock operas together in one place.

Often, when we're creating software for working with directories in files,

we wanna be able to search for particular files and directories.

Luckily, Python makes this pretty easy for us.

So I've imported os.

I'm gonna do os.listdir, and you can see all of the files and

directories that are currently in this directory.

Those dir method gives us back everything that's in the directory.

By default, it uses the current working directory,

but we can provide it a path right here if you wanted to.

And it'll tell you everything that's in that path.

Slightly more useful though, is the scan dir method.

Now we're gonna pass this one to list because it gives us an iterable to consume

and we wouldn't see anything good if we didn't pass it to list.

So we can see here all of these dir entries.

Each one of these dir entries is an object that represents an entry in the directory,

so it's either a file or it's a directory or whatever.

What's cool about these is we can use them to get some basic information about their

equivalent entry without having to go back to the file system and

inspect a particular file.

For instance, let's look at this one here.

So, 0123.

Okay?

So, I'm going to say files=list(os.scandir).

And then I'm gonna say files(3).name.

And I get bootstrap-3.3.7-dist.zip which you can get off

the getbootstrap.com website.

So let's find out if files[3] is a file.

And it is, so cool.

So now I can get some statistics about the object by using the stat method.

So I can do files[3] and then I can say stat.

And I get these stat results.

Now the one of these that is the most useful,

the most interesting is this one over here, this ST size.

This is the size of the file in bytes.

This is really handy if you wanted to, for example,

flag files that are above a certain size.

Now one more thing to bring up.

Scan dir gives you a stream like iterator.

Like when you use the open function.

So if you're not consuming it right away, and then ending the block it's in.

Like a for loop or a function.

Or you're not using it with a context manager like With.

You'll want to call the close method on it.

So for instance if I had scanner = os.scandir() I would

eventually want to do scanner.close.

That would close out the scanner and free up memory.

Now, let me show you another way to work your way through directories.

We can use the os.walk method to step through all of the files and

directories in a particular directory.

This isn't exactly the same as using scandir, but

it gives us a handy way to explore file trees.

I've already started, but I'm going to finish a script here called tree.py.

And I say started, I've created a file.

Now inside here, in this directory, I have a bootstrap directory and

that's full of all the files that you get when you download bootstrap.

So, I want to look through that.

So, I'm gonna import OS, and

then I'm gonna make a new function named treewalker.

And it's going to start at some directory.

So, my total size is 0.

And my total number of files is 0.

So for the root, for the dirs and for

the files that are in os.walk(start) whatever the start directory is.

My subtotal is going to be equal to the sum of os.path.getsize(),

which is similar to doing the os.stat and then pulling out the ST_SIZE.

But getsize just pulls directly that off.

And I'm gonna use os.path.join, and the root, and

the name, and I'm gonna do that for every name that's in files.

And then I'm gonna say that total_size will have the subtotal added to it.

And I'm gonna say that file_count will be equal to the len(files).

Total number of files over there.

And then total files is going to plus equal the file count.

Now I could of course just combine those two lines but

sometimes it's nice to print the whole thing out.

So,I'm gonna print root and then consumes.

And I'm gonna end that with a space, and

then I'm gonna print the subtotal, and end that with a space.

And then I'm gonna print bytes in, and then the file count,

and I'm gonna say non-directory files.

And then out here outside of the for loop, I'm gonna print start

contains and then total_files.

And then files with a combined size of,

and then total size, and then bytes.

So a lot of stuff to do there.

But then I'm gonna call treewalker down here with Bootstrap.

There we go, save that, come back over here, and

I'm gonna execute tree.py.

So Bootstrap has zero bytes, and zero non directory files.

Bootstrap css consumes 1.3 million bytes in 8 non-directory files.

Bootstrap fonts contains 215,000 bytes.

Bootstrap.js is 117,000.

Bootstrap in total has 16 files with a combined size of 1.6 million bytes.

So that's pretty cool.

That's a really nice way just to kind of quickly see what's going on.

There's a lot more to the OS module, and

we're going to explore some more of it in the next two sections.

Feel free though to explore it a bit more on your own.

It's one of the more interesting modules in Python, especially since dealing with

differences and operating systems is often such a thorny area.

All right, take a little break, have a snack or stretch, and then come back to

learn about manipulating files with Python, instead of just looking at them.