Added 4 approaches as examples of possible solutions based on the intro.

Author: BethanyG

exercises/practice/dnd-character/.approaches/ability-method/content.md

@@ -0,0 +1,43 @@
+# Use the `ability()` Method to Generate and Return the Dice Rolls
+
+
+```python
+from random import sample
+
+class Character:
+    def __init__(self):
+        self.strength = self.ability()
+        self.dexterity = self.ability()
+        self.constitution = self.ability()
+        self.intelligence = self.ability()
+        self.wisdom = self.ability()
+        self.charisma = self.ability()
+        
+        self.hitpoints = 10 + modifier(self.constitution)
+
+    def ability(self):
+        values = sample(range(1, 7), 4)
+        return sum(values) - min(values)
+        
+def modifier(constitution):
+    return (constitution - 10)//2
+```
+
+
+This approach uses a single `ability()` method to calculate the dice rolls and return an ability value.
+`ability()` is then called in `__init__()` to populate the listed-out character attributes.
+`self.hitpoints` calls the stand-alone `modifier()` function, adding it to 10 for the character's hitpoints attribute.
+
+This approach is valid and passes all the tests.
+However, it will trigger an analyzer comment about there being "too few public methods", since there are no methods for this class beyond the one that calculates attribute values.
+
+
+The "too few" rule encourages you to think about the design of the class: is it worth the effort to create the class if it only holds attribute values for a character?
+What other functionality should this class hold?
+Should you separate dice rolls from ability values?
+Is the class better as a [dataclass][dataclass], with dice roll as a utility function?
+
+None of these (_including the analyzer complaint about too few methods_) is a hard and fast rule or requirement - all are considerations for the class as you build out a larger program.
+
+
+[dataclass]: https://docs.python.org/3/library/dataclasses.html

exercises/practice/dnd-character/.approaches/dice-roll-static-method/content.md

@@ -0,0 +1,47 @@
+# Move Dice Rolls Into a Static Method Separate from the `ability` Method
+
+
+```python
+from math import floor
+from random import choice
+
+class Character:
+    def __init__(self):
+        self.strength = Character.dice_rolls()
+        self.dexterity = Character.dice_rolls()
+        self.constitution = Character.dice_rolls()
+        self.intelligence = Character.dice_rolls()
+        self.wisdom = Character.dice_rolls()
+        self.charisma = Character.dice_rolls()
+        
+        self.hitpoints = 10 + modifier(self.constitution)
+
+    def ability(self):
+        return choice([*vars(self).values()])
+        
+    @staticmethod    
+    def dice_rolls():
+        values = sorted(choice(range(1,7)) for dice in range(4))[::-1]
+        return sum(values[:-1])
+
+def modifier(constitution):
+    return floor((constitution - 10)/2)
+```
+
+This approach separates the `ability()` method from a [`static method`][staticmethod] that calculates dice rolls.
+`ability()` returns the value of a randomly chosen character ability using [`random.choice`][random-choice] but does not roll dice or calculate values.
+Instead, `dice_rolls()` handles the rolls/values using [`random.choice`][random-choice] for selection.
+
+The argument for this is that the logic/functionality of rolling dice 4 times and summing the top three values is not really related to a DnD character or their abilities - it is independent and likely useful across a wider scope than just the character class.
+However, it might be tidier to include it in the character class, rather than "clutter" the program or module with an additional stand-alone function.
+Declaring `dice_rolls()` as a static method allows other callers to use the function with or without instantiating a new  `Character` object.
+It also makes it cleaner to maintain, should the method or number of the dice rolls change.
+
+`dice_rolls()` is then called in `__init__()` to populate the listed-out character attributes.
+Note that it needs to be called with the class name: `Character.dice_rolls()`.
+`self.hitpoints` then calls the second stand-alone `modifier()` function, adding it to 10 for the character's `hitpoints` attribute.
+`modifieer()` in this example uses [`math.floor`][math-floor] for calculating the `hitpoints` value.
+
+[math-floor]: https://docs.python.org/3/library/math.html#math.floor
+[random-choice]: https://docs.python.org/3/library/random.html#random.choice
+[staticmethod]: https://docs.python.org/3/library/functions.html#staticmethod

exercises/practice/dnd-character/.approaches/loop-and-setattr-in-init/content.md

@@ -0,0 +1,84 @@
+# Loop Through an Abilities Tuple to Set Attribute Values in `__init__`
+
+
+```python
+from random import choice, sample
+
+class Character:
+    
+    abilities = ('strength', 'dexterity', 'constitution', 'intelligence', 'wisdom', 'charisma')
+
+    def __init__(self):
+        for ability_type in Character.abilities:
+            setattr(self, ability_type, Character.dice_rolls())
+        
+        self.hitpoints = 10 + modifier(self.constitution)
+
+    def ability(self):
+        return choice([*vars(self).values()])
+          
+    @staticmethod    
+    def dice_rolls():
+        values = sample(range(1, 7), 4)
+        return sum(values) - min(values)
+        
+def modifier(constitution):
+    return (constitution - 10)//2
+```
+
+
+This approach uses a `tuple` to hold character attributes in a [`class variable`][class-variable] or `class attribute`.
+Since this variable is common to all instances of the class, it can be looped through during object initialization to create instance variables and assign them values using [`setattr] [setattr].
+
+This strategy has several benefits:
+1.  The `__init__`  is less verbose and the abilities are easier to maintain.
+2.  Organizationally, attributes remain with the class, making it clearer where they apply.
+3.  Attributes are inherited in any subclass and can be added to or overridden by them.
+4.  Changes to attributes are reflected in all new objets and subclasses automatically.
+
+Because `hitpoints` is calculated differently, it is assigned a value outside the `tuple` and `loop`.
+
+The remainder of the class body is the same as in the [dice roll static method][approach-dice-roll-static-method] approach (_as is the variant below_).
+
+
+```python
+from random import choice, sample
+
+CHARACTER_ABILITIES = ('strength', 'dexterity', 'constitution',
+             'intelligence', 'wisdom', 'charisma')
+
+class Character:
+    
+    def __init__(self):
+        for ability_type in CHARACTER_ABILITIES:
+            setattr(self, ability_type, Character.dice_rolls())
+        
+        self.hitpoints = 10 + modifier(self.constitution)
+
+    def ability(self):
+        return choice([*vars(self).values()])
+          
+    @staticmethod    
+    def dice_rolls():
+        values = sample(range(1, 7), 4)
+        return sum(values) - min(values)
+        
+def modifier(constitution):
+    return (constitution - 10)//2
+```
+
+Above, the character attributes are moved out of the class into a [`constant`][constant] at the module level.
+The Character `__init__` method loops through them using `setattr` to create instance variables and assign them values, similar to the first example.
+Again, because `hitpoints` is calculated differently, it is assigned a value outside the `tuple` and `loop`.
+Making the character attributes a constant has the advantage of being visible to all other classes and functions defined in the module.
+ This could be easier if the attributes are being used by multiple classes beyond the Character class.
+This also avoids having to reference the Character class when using or modifying the abilities and could help with clarity and maintenance in the larger program.
+However, modifying the abilities in this context would also be visible at the module level, and could have wide or unintended consequences, so should be commented/documented carefully.
+
+The remainder of the class body is the same as in the [dice roll static method][approach-dice-roll-static-method] approach (_as is the variant below_).
+
+
+[approach-dice-roll-static-method]: https://exercism.org/tracks/python/exercises/dnd-character/approaches/dice-roll-static-method
+[class-variable]: https://docs.python.org/3/tutorial/classes.html#class-and-instance-variables
+[constant]: https://peps.python.org/pep-0008/#constants
+[setattr]: https://docs.python.org/3/library/functions.html#setattr

exercises/practice/dnd-character/.approaches/stand-alone-dice-roll-function/content.md

@@ -0,0 +1,99 @@
+# Separate Dice Rolls into a Stand-Alone Dice Roll Function
+
+
+```python
+from random import choice, randint
+from operator import floordiv
+
+
+class Character:
+    def __init__(self):
+        self.strength = dice_rolls()
+        self.dexterity = dice_rolls()
+        self.constitution = dice_rolls()
+        self.intelligence = dice_rolls()
+        self.wisdom = dice_rolls()
+        self.charisma = dice_rolls()
+        
+        self.hitpoints = 10 + modifier(self.constitution)
+
+    def ability(self):
+        return choice([*vars(self).values()])
+    
+        
+def dice_rolls():
+    values = sorted(randint(1, 6) for item in range(4))
+    return sum(values[1:])
+
+def modifier(constitution):
+    return floordiv((constitution - 10), 2)
+```
+
+
+This approach separates the `ability()` method from a stand-alone function that calculates dice rolls.
+`ability()` returns the value of a randomly chosen character ability using [`random.choice`][randon-choice], but does not roll dice or calculate values.
+Instead, `dice_rolls()` handles the rolls/values, using [`random.randint`][random-randint] to generate them.
+The argument for this is that the logic/functionality of rolling dice 4 times and summing the top three values is not really related to a DnD character or their abilities - it is independent and likely useful across a wider scope than just the character class.
+It also makes it cleaner to maintain, should the method or number of the dice rolls change.
+
+`dice_rolls()` is then called in `__init__()` to populate the listed-out character attributes.
+`self.hitpoints` calls the second stand-alone `modifier()` function, adding it to 10 for the character's `hitpoints` attribute.
+Note that `modifier()` uses the [`operator.floordiv`][operator-floordiv] method to trunkate the value.
+
+This approach is valid and passes all the tests.
+However, it will trigger an analyzer comment about there being "too few public methods", since there are no methods for this class beyond `attribute()`.
+
+The "too few" rule encourages you to think about the design of the class: is it worth the effort to create the class if it only holds attribute values for a character?
+What other functionality should this class hold?
+Should the `dice_roll()` function be outside or inside (_as a regular method or a static method_) the class?
+
+None of these (_including the analyzer complaint about too few methods_) is a hard and fast rule or requirement - all are considerations for the class as you build out a larger program.
+
+An alternative is to write a [dataclass][dataclass], although the design discussion and questions above remain the same:
+
+
+```python
+from random import choice, sample
+from dataclasses import dataclass
+
+@dataclass
+class Character:
+    
+    strength: int = 0
+    dexterity: int = 0
+    constitution: int = 0
+    intelligence: int = 0
+    wisdom: int = 0
+    charisma: int = 0
+    hitpoints: int = 0
+    
+    def __post_init__(self):
+        for ability in vars(self):
+            setattr(self, ability, dice_rolls())
+        
+        self.hitpoints = 10 + modifier(self.constitution)
+
+    def ability(self):
+        return choice([*vars(self).values()])
+          
+  
+def dice_rolls():
+    values = sample(range(1, 7), 4)
+    return sum(values) - min(values)
+        
+def modifier(constitution):
+    return (constitution - 10)//2
+```
+
+
+Note that here there is a [`__post_init__`][post-init] method to assign ability values to the attributes, and that the attributes must start with a default value (_otherwise, they can't be assigned to in post-init_).
+`hitpoints` has the same treatment as the other attributes, and requires assignment in post-init.
+
+`dice_rolls()` uses [`random.sample`][random-sample] for roll values here and `modifier()` uses the floor-division operator `//`.
+
+[dataclass]: https://docs.python.org/3/library/dataclasses.html
+[operator-floordiv]: https://docs.python.org/3/library/operator.html#operator.floordiv
+[post-init]: https://docs.python.org/3/library/dataclasses.html#post-init-processing
+[random-randint]: https://docs.python.org/3/library/random.html#random.randint
+[random-sample]: https://docs.python.org/3/library/random.html#random.randint
+[randon-choice]: https://docs.python.org/3/library/random.html#random.choice