[SOUND] You've learned a ton about object oriented programming in Python.

You've learned to make your own classes.

Either from the ground up.

Or by building on top of Python's built in classes.

You've also taken advantage of magic methods.

Class methods.

And properties.

To make your classes smarter and cleaner.

You're doing amazing.

We haven't built anything larger and more complex together, though.

You know me.

I like to build games with you as a learning tool.

When I was first planning this course out.

I wanted to build a terminal version of Yahtzee.

With die rolling, and re-rolling, hand scoring.

And even human and bot players.

Yeah, that wasn't as simple as I thought it would be.

When I did complete it.

It was just way too much to teach in a course.

So let's scale it back.

And build something that's less for one specific game.

And maybe a bit more universally useful.

Over the next few videos.

We'll build a small utility.

To roll a specific number of dice with a specific number of sides.

You could roll two 20-sided dice or

five six-sided dice or whatever your game requires.

While this isn't quite as exciting as a full game.

It'll give us a lot more practice with building smart classes.

And it'll be a utility we can use for building other games.

As we continue working with Python.

Get a drink or a snack.

Take a nap if you need it.

And then let's start.

By defining exactly what our code dice should do.

All right, we want a die that has a certain number of sides.

And then a random value between 1 and the number of sides.

And we could base this on int.

But that actually raises a fair number of issues.

It's easier and arguably cleaner to just make our own class.

We can control the creation of the class.

And we can make it a little easier to subclass for other die types.

Now I've created a directory named yatzy.

And I've created a file named dice.py.

You wanna go ahead and do those.

If they're not in your workspace.

So then let's import random.

And lets create our die class.

So find our init [INAUDIBLE] self.

I think we want two arguments.

I think we want a sides.

And we'll default that to two.

And let's let them set a value.

Just in case they want the die to be four or whatever.

For testing purposes.

So, okay, so we take a number of sides and we take a value.

And we want to make sure that sides >= 2.

Otherwise we should raise ValueError(.

That says, must have at least 2 sides.

If you can show me a one sided die, I would love to see it.

And let's make sure that sides is an int.

So if not is instance(sides, int): We're going to raise

another value error that says sides must be a whole number.

Now, arguably, that might ought to be a type error instead of a value error,.

But I figured they gave me the wrong value, so it's a value error.

So then let's say that self.value = value.

That was passed in, or random.randint (1, sides.

So something between 1 and sides.

We can't have a number below 1.

And it can't be above the number of sides that there are.

Now, we're not taking into account if you had a strange die that had

only even numbers or something like that.

And we might want to have a check.

To make sure that value is also an int.

But I'll leave that up to you.

Okay, we have enough here to try out our really simple die.

So let's come down here.

And Python from dice import.

I need to exit.

Let me get into Yatzy.

Python from dice import die.

And then let's say that d is equal to die, d.value.

There's 2.

And let's say d6 is equal to die.

And sides is equals to 6 and the 6 sides.

And then we do d6.value we get 2 there as well.

All right, so it rolled a random number for us twice.

So cool.

Now, let's go back and let's make a die class that extends our die.

But is always a six sided die.

Right? Because that's

a pretty common need, right?

There are lots of games out there that need six sided dice.

The convention is to call a die D.

And then the number of sides that it has.

At least in role playing circles.

So we're gonna call this a d6.

Ad this is going to extend die.

But we're gonna override init.

We're still gonna take value.

We're not gonna take sides.

Because we don't care how many sides they want, right?

The sides on this is always gonna be six.

So we're gonna call super and then the init method.

We're gonna say size equals six, and value equals value.

We'll just pass value on through.

And that's it for our class.

Since we set up our Die class to take a number of sides.

We can just hardcode that in our D6 class.

So, let's test this one out.

So we're gonna import dice and then we'll say, d6 = dice.D6().

And then if we do d6.value we get a 3.

Nice.

Now we could go further.

And turn this into a 12 sided or a 20 sided.

Or whatever number of sides the dice in our game require.

So feel free to do that if you want to.