[MUSIC]

All programmers eventually have to deal with dates and times.

Sometimes at the same time, and eventually,

you're going to have to deal with time zones too.

All of this can be a big mess, but thankfully,

Python gives us some really solid tools for dealing with them.

We'll be using the datetime library for everything in this course.

So get used to importing datetime.

So first things first, we're gonna want to import datetime.

So we'll type that out and

we're gonna be using a class from datetime that's named datetime.

Yeah, this can be a little confusing, but you'd get used to it pretty quickly.

Basically, datetime has four major modules that you'll sometimes use, maybe five.

It's got date, time, and then those combined become datetime.

So we have date, we have time, and we have datetime.

And then you'll find that we're gonna use timedelta quite a bit.

And we may also be using timezone toward the end.

You won't really use tzinfo on its own.

You're not supposed to.

And then really time and date don't end up getting used a whole lot.

You mostly use datetime itself.

So, let's look at what datetime does.

It lets us work, as I've just said, with both times and dates at the same time.

For right now though, let's just play with two methods that datetime gives us.

Sorry, datetime.datetime.

Yeah, that gets confusing, doesn't it?

So anyway, those two methods are .now and .replace.

So let's try datetime.datetime.now.

And you can see that it's 2014, it's the 10th month, the 15th day,

the 18th hour on our server, the 23rd minute, 0 seconds and

596,134 microseconds, which is a millionth of a second.

Yeah, anyway, something like that.

All right, that's the current date.

Well, it's not right now, it's the now that was right now when I ran that method.

It's really best if you don't think about it too much.

Let's, let's make a new variable.

We'll call this treehouse_start, and it'll be datetime.datetime.now.

So let's look at that.

That's a similar date to what we'd had a minute ago.

But actually, I want to do treehouse_start.replace.

And I want to turn the hour into 9, the minute into 0, and

the second into 0, and the microsecond into 0.

Oh, we wanna do treehouse_start equals

treehouse_start.replace, hour equals 9,

minute equals 0, second equals 0, microsecond equals o.

All right, so now, if we look at treehouse_start, we get,

that I started at 9 AM this morning.

So what does this replace method that do?

Well, if the name didn't give it away,

it lets you replace attributes of our datetime object.

So we can replace the hour, the minute, the second, or the microsecond.

We can also replace the year, the month, the day, whatever we need to replace.

This comes in really handy when you need to make your dates and times some time

other than now, but you don't want to deal with the other ways of creating them.

Which, lets talk about that.

We could also have done.

I'll do this one as th-start, datetime.datetime, 2014, 10, 15, 9.

And if I look at th_start,

and I look at treehouse_start, they're the same thing.

But sometimes you don't want to just fill in those variables,

you want to I want all these things as they're gonna come out.

I want the year, the month, the day.

I just wanna change the hour to be, in this case 9 AM,

or to be midnight or whatever.

Okay, so lets see how long I've been at work, according to the server,

which is a little different from my computer I'm actually typing on.

So we'll do datetime.datetime.now.

And I'm gonna subtract from that, treehouse_start.

And, we get back this new thing here called a timedelta, and it's got some

numbers that don't necessarily make a lot of sense, this 33972 and 762540.

What those actually are, the 0 is days.

And the other measures there.

So the 0 is days, the second number is the number of seconds, and the third

one here is the number of microseconds, which are a thousand milliseconds.

So a millionth of a second.

So it's been 0 days, 33,972 seconds and

762,540 microseconds since I started work according to the server.

Okay.

How do we turn that into hours though?

Let's, let's turn it into a variable.

We'll do time_worked equals

datetime.datetime.now minus treehouse_start.

Okay?

And so, time_worked is gonna be very similar to that

number that we have before, and let's see what it has in here.

Let's do time_worked.days, 0 days, correct?

All right, and microseconds.

There's that 850,000 number.

And if we just did seconds, okay.

Let's actually do a dir on time_worked and see what we get.

So, we can see that this has days, max,

microseconds, it's got a lot of stuff here.

If we have the seconds though, we can calculate the hours.

There are 60 seconds in a minute, 60 minutes in an hour.

So if we divide our time worked seconds attribute by 3600, then we have our hours.

Lets round those so that it might look a little bit more impressive.

I don't know. We'll see.

So time_worked.seconds divided by 3600.

Notice no spaces around my divide sign cuz I'm inside a function call.

And hours_worked is 9.

That's not accurate.

The server is in a different timezone.

I, I imagine the server is set to UCT time, so it thinks it's a little further

than it actually is, but you get the idea of rounding these things.

So, awesome.

It thinks I've been to work for 9 hours.

Oh, if only.

Wow, that was a lot for just the first video, datetime objects,

timedelta objects, and we're already manipulating time.

We can actually do a lot with timedeltas, so let's explore them a bit more.