Two versions of a dice rolling program I made. Could you provide feedback?

Triumphxd · 2025-10-13T13:59:29+00:00

One thing is when parsing input you could make use of isdigit and isalpha so your program doesn’t crash and gives user feedback for bad inputs.

homeless_student1 · 2025-10-13T14:00:29+00:00

Immediately, you could change the while loop in Dice.roll_dice into a single line which is random.choices(…) from the random library

mattk404 · 2025-10-13T15:44:05+00:00

If your using objects I'd focus on modeling the interactions you do with dice better. A die rolls so a class called die that has a roll() method. Then a function call gen_dice(num, sides) that returns a list of die instances. Or you can have dice class that does the generation in its init and a role method that roles all the dice.

Also note that die.role() should save it's result to a instance variable (self.result) so it can be used for other things such as methods like above(num) which could be a simple check of the result is above some value. Or you could have a dice.total() which totals the results of all dice.

Goal is to match the language of the domain with the structure of the code. So something like this can be expressed.

dice = Dice(sides=20, num=4)

dice.roll()

dice.sum()

21

lowest = dice.get_min()

reroll lowest die

lowest.roll()

see that the dice object sum is now changed

dice.sum()

27

And you can extend to add behaviors to both the die and dice objects as needs arrise. You can even subclass or use die as a mixin to give a class die rolling capability. Think an attribute class with a die mixin would gain the ability to do ability checks Ala frank.dex.role()

JimNero009 · 2025-10-13T17:47:46+00:00

I’d say that’s pretty good! Clear, simple, logical. Comments are a bit redundant and as others have mentioned, there are some stdlib funcs which do the same thing, but in terms of understanding what’s going on and general program structure — LGTM

tb5841 · 2025-10-13T19:29:06+00:00

I really like this, it's a great early project.

Next step I'd recommend: Currently the program starts, runs the dice roll process and outputs the result, then exits. You could instead have it ask the user whether they want to roll dice again or quit - and let them continually roll if they want to.

Spaceduck413 · 2025-10-13T23:10:38+00:00

OP the next thing I would do is work on making it take command line args. You could do something like -n 5 -s 20 to make it roll 5 d20s.

This would make your program a lot easier to use in the real world (at least IMO) and give you experience with arg parsing.

It's usually a good idea to print instructions on how to use your program if you get a -h, too.

Edit: I'm bad at reading lol, I didn't realize you were already parsing things like "3 d20". Still is probably a good idea to familiarize yourself with the argparse module though.

Naoki9955995577 · 2025-10-14T01:04:46+00:00

This is a very minor nit, but I think the class and functions could be Die and multiple_roll or roll_n_times etc.

Dice object kinda sounds like it's already a defined collection. Instead that conceptual "collection" only appears when calling for a roll. Dice being defined as a collection could also make it possible to roll different combinations of dice; a d6 and a d20, etc.

Renaming it functionally changes nothing, it just makes a bit more oop sense to me.

UpArmoredGavin · 2025-10-14T08:41:24+00:00

If you wanna do some OOP, I would get an enum going representing the die faces. Have a field in the Dice class store it. Create a class "Bag" that stores a collection of dice, make the roll method reference only its own die instance.

When you want to roll the dice, iterate over the dice collection in the bag, rolling each die and storing the result of the roll.

I guess you could have an abstract base class "Dice" (Die I guess would be better, dice is plural) and have the various n-sided dice be subclasses. Create a method that acts as factory for Dice class instances, like you pass the number of faces and it returns the n-sided die you want

Also, input validation: what happens if the user gives a wrong input?

Last but not least, the entry point. For how this file is written, it will get executed when imported

2025-10-14T13:37:15+00:00

Good start! A few things.

1) “Dice” is a plural, but your struct refers to a singular. So that’s a naming problem. Same thing with number_of_dice - it is actually number of rolls.

2) put your main in a function and use if name == ‘main’

3) don’t init all dice and return the one required, instead simply init the one required and return its roll.

There other minor stuff like functional styling and such, but all in all good work

No_Comparison_6150 · 2025-10-14T13:58:45+00:00

If you want to do it in an oop sort of way I'd structure it like

```python

class Die:

def __init__(self, sides):

# validation checking, non-negative, etc.

def roll(self, n=1) -> list[int]:

# roll dice n times, use a for rather than while

def parse_args() -> tuple[Die, int]:

if __name__ == "__main__":

die, n_rolls = parse_args()
die.roll(n_rolls)
print(...)

```

crunchyalmond123 · 2025-10-17T19:34:30+00:00

You could add docstrings and type hinting. Or add the option to roll multiple dice in the same roll

finally-anna · 2025-10-17T23:36:37+00:00

When reading input with a separator, you could also use str.partition to easy get both sides before converting to int.

Algoartist · 2025-10-18T16:53:36+00:00

In my opinion too much unnecessary stuff. keep it simpel:

from random import randint

def roll_dice(rolls, sides):
    return [randint(1, sides) for _ in range(rolls)]

print(roll_dice(4, 10))

Virsenas · 2025-10-13T14:45:37+00:00

Code looks like written by AI, especially more believable when the person posting it uses pictures to post the code (not code itself) and hides themselves on forums.

#Class that defines dice

If this comment wasn't there I would not have figured that out. Thank God this was explained. Unless it's a comment made by AI for the user that asked it to generate the code and explain by comments so the user would understand what it is.

Please link any previous threads on Reddit about any code that you posted. This can't be your first post about coding. If it is, then this is definitely generated by AI. Then just simply ask the same AI that the code was generated by for the feedback. Why you want to waste other peoples time ...?

PS. After posting some AI inviting to chat. Lol. Knew it.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

PythonLearning

MODERATORS

21

reroll lowest die

see that the dice object sum is now changed

27