Unable to create a roll method in Hand

Can anyone provide a method for thinking through this problem? All throughout this course I have had issues with the code challenges because I cannot seem to come up with the methodology to approach these problems based on what I learned in the videos. I usually just de-construct some else's answer and try to understand how they come up with it. This case is no different: I cannot even begin to think about how to approach this!

Assma Al-Adawi This took me a while, but I finally figured it out.

Let's break down the problem. It states: "I'm going to use code similar to Hand.roll(2) and I want to get back an instance of Hand with two D20s rolled in it. I should then be able to call .total on the instance to get the total of the two dice."

The first thing to do is carefully read the problem and restate it to make sure you understand what is being asked. For example, "I need to write a method called roll() which takes a number and creates that many D20 dice. The total() method uses sum() to add up the dice values. Sum() takes an iterable, like a list. So the roll() method will create a list of dice, which makes sense because Hand is a subclass of list." Something like that.

The clue that Kenneth gave was that you're going to call it on Hand (the class), not an instance of Hand. What kind of method do you call directly on the class?

The books.py example from earlier in the course was helpful. Take a look at that and try to solve it before reading further.

class Bookcase:
    def __init(self, books=None):
        self.books = books

    @classmethod
    def create_bookcase(cls, book_list):
        books = []
        for title, author in book_list:
            books.append(Book(title, author))
        return cls(books)

As others already pointed out, it's a class method, so you put the @classmethod decorator above the class declaration. Class methods don't take self, but cls as the first argument, because you're calling it on the class, not an instance (self). Then you would put in the other argument, which is the number of dice you're creating. You can call that size.

Then, for that many (you can call range() on size), you're going to create a D20 die. So you'll need a for loop and inside the loop you'll create a die. How do you create a D20 die?

Since the function needs to return a list, the dice will need to be appended to a list. You can initialize an empty list and then append to it inside the for loop.

Finally, you'll need to return the list of dice and call cls() on the list to convert it into a Hand. (Is that correct Kenneth Love ? I couldn't find the explanation in the Python docs.)

To test the code, you can try:

Hand.roll(2).total

Read the instructions again. My example code was Hand.roll(2). What isn't being created in the example? What kind of method does roll need to be?

One of the worst challenges ever. My solution works on Jupyter Notebook but here I get Bummer! Can't get the length of a 'Hand'. This OOP course sucks! Here is my solution that works on Jupyter Notebook:

from dice import D20

class Hand(list):
    def __init__(self, size=0, die_class=None, *args, **kwargs):
        if not die_class:
            raise ValueError("die_class must be provided.")
        super().__init__()

        for _ in range(size):
            self.append(die_class()) # Creating instances of die_class

        # Sorting
        self.sort()

    @classmethod
    def roll(cls, size, die_class=D20):
        return cls(size=size, die_class=die_class)

    @property
    def total(self):
        return sum(self)

h = Hand.roll(2)
print('Length: ', len(h))
print('Hand: ', h)
print('Total: ', h.total)

>>> Length:  2
>>> Hand:  [14, 18]
>>> Total:  32

Here is my solution, I only post this as reference for people stuck on the challenge. There are other approaches in this thread but they are either too clunky or use concepts I'm not very strong on (classmethods). Happy learning!

'''python

from dice import D20

class Hand(list): @property def total(self): return sum(self)

def __init__(self, size = 0, *args, **kwargs):  //We dont really care about initialisation because the roll function is important here
    super().__init__()  


def roll(self, size):
    for x in range(size):
        self.append(int(D20())) // appending with the value of each dice to the Hand Object

'''

I just used your code and added the following lines:

h = Hand.roll(2) t = h.total

and it worked fine for me. Thanks for your help in resolving this issue Zac.

I tried the following code and was unable to get this working:

from dice import D20

class Hand(list): @property def total(self): return sum(self)

def __init__(self, sides=0, die_class=None, *args, **kwargs):
    if not die_class:
        raise ValueError("You must provide a die class")
    super().__init__()

    for _ in range(sides):
        self.append(die_class())

@classmethod
 def roll(cls, sides=2):
    return cls(sides=sides, die_class=D20)

h = Hand.roll(2) t = h.total

Could someone please tell me what I am missing with this code?

After a crazy amount of frustration, I figured it out.

from dice import D20

class Hand(list):
    def __init__(self, size=0, die_class=D20, *args, **kwargs):
        super().__init__()
        for _ in range(size):
            self.append(die_class())

    @classmethod
    def roll(cls, size=2):
        return cls(size=size)

    @property
    def total(self):
        return sum(self)

You were right. I forgot about classmethods. Thank you for all you do here at Treehouse! Your courses are excellent.

Terribly taught course. Need to redo Treehouse.

Here what I read found working thanks to community here, I have some knowledge about Java and OOP but this course not helpfull much.

from dice import D20

class Hand(list):

def __init__(self, size=0, die_class=D20):
    super().__init__()
    for _ in range(size):
        self.append(die_class())

@classmethod
def roll(cls, size=2):
    return cls(size=size)

@property
def total(self):
    return sum(self)

Hey guys, not sure who this is still a problem for. But I just looked through all of this and and using the last bit of code I cam up for the answer.

@zachary looked like he had it right.

Only thing I changed is in def roll, I only passes size as is. So like this

def roll(cls, size): return cls(size)

Everything else is the same.

I didn't think of setting the die_class=D20 in the init, I was doing it in the roll with a super like the video,

Also not sure why I didnt use cls as a parameter in the roll().

I'm actually still not sure why that's there.

from dice import D20
class Hand(list):
    @property
    def total(self):
        return sum(self)
    @classmethod
    def roll(cls, size):
        empty = []
        for i in range(size):
            i = D20()
            empty.append(i)
        return cls(empty)

This is the solution, ursaminor really helped me out with calling cls() on the list at the end. I still dont understand what that does, but the rest of the thinking makes sense to me.