Inventory Dicts Improvement (exercism#2770)

* Inventory Dicts Improvment

* proofing the about file

* check working

* add Bethany

* Update languages/concepts/dicts/about.md

* Update languages/concepts/dicts/about.md

Co-authored-by: BethanyG <[email protected]>

Author: 2 people

concepts/dicts/about.md

@@ -0,0 +1,41 @@
+A dictionary in Python is a data structure that associates [hashable][term-hashable] _keys_ to _values_ and can be known in other programming languages as a [hash table or hashmap][hashtable-wikipedia]. In Python, it's considered a [mapping type][mapping-types-dict]. `dicts` enable the retrieval of a value in constant time, given the key.
+
+Compared to searching for a value within a list or array (_without knowing the index position_), a dictionary uses significantly more memory, but has very rapid retrieval. It's especially useful in scenarios where the collection is large and must be accessed frequently.
+
+## Keys and Values
+
+A dictionary can be though of as a collection of straightforward `key`:`value` pairs. Like other collection types (`list`, `tuple`, and `set`), `values` can contain arbitrary data and data types, including nested dictionaries. A dictionary’s `keys` are _**almost**_ as arbitrary, but require their data types to be _hashable_.
+
+Keys are unique across a dictionary, and the values associated with any `key` can be replaced, updated or altered as long as the `key` exists. To be a valid, a key (_and all its contained values_) must be [hashable][term-hashable]. Hashable `keys` can include numbers, strings, tuples of _immutable_ values, or frozensets. `sets`, `lists`, and `dicts` are unhashable and therefor cannot be used as keys.
+
+A value can be of any data type, including built-in types, custom types or complex objects (even functions or classes). Commonly used objects are: numbers, strings, lists, dictionaries, tuples or sets.
+
+A simple `dict` can be declared using the literal form `{"key_1": value_1, "key_2": value_2}` or via _constructor_ with `dict(key_1=value_1, key_2=value_2)`, but there are many more ways of creating and initializing dictionaries including the use of a _dict comprehension_ or passing additional constructor parameters as illustrated in the [Python docs][mapping-types-dict].
+
+Inserting a new `key`:`value` pair can be done with `dict[key] = value` and the value can be retrieved by using `retrieved_value = dict[key]`.
+
+## Methods
+
+`dicts` implement various methods to allow easy initialization, updating and viewing.
+
+Some useful `dict` methods:
+
+- Retrieve a value "safely" from a dictionary by using the `.get(key, [default])` method. `.get(key, [default])` returns the value for the key **or** the _default value_ if the key is not found, instead of raising a `KeyError`. This works well in situations where you would rather not have extra error handling but cannot trust that a looked-for key will be present.
+- Retrieve a value "safely" or insert a default _value_ if the key is not found using the `.setdefault(key, [default])` method. `setdefault(key, [default])` will insert the default value in the dictionary **only** if the key is not found, then it will retrieve either the **newly inserted** default value if the key was not found or the **unchanged** existing value if the key was found.
+- Return various _iterable_ views of your `dict` with `.keys()`, `.values()`, `.items()` (_an iterable of (key, value) `tuples`_).
+
+For a detailed explanation of dictionaries in Python, the [official documentation][dicts-docs] is an excellent starting place, or you can also check out the [W3-Schools][how-to-dicts] tutorial.
+
+## Extending Dictionaries: The collections module
+
+The [`collections`][collections-docs] module adds more functionality to Python's standard collection-based datatypes (`dictionary`, `set`, `list`, `tuple`). A popular `dict`-oriented member of this module is the [`Counter`][counter-dicts], which automatically counts items and returns them a `dict` with the items as keys and their counts as values. There is also the [`OrderedDict`][ordered-dicts-docs], which has methods specialized for re-arranging the order of a dictionary. Finally, there is the [`defaultdict`][default-dicts], a subclass of the built-in `dict` module that, based on a factory method, sets a default value if a key is not found when trying to retrieve or assign the value.
+
+[term-hashable]: https://docs.python.org/3/glossary.html#term-hashable
+[hashtable-wikipedia]: https://en.wikipedia.org/wiki/Hash_table
+[mapping-types-dict]: https://docs.python.org/3/library/stdtypes.html#mapping-types-dict
+[dicts-docs]: https://docs.python.org/3/tutorial/datastructures.html#dictionaries
+[how-to-dicts]: https://www.w3schools.com/python/python_dictionaries.asp
+[collections-docs]: https://docs.python.org/3/library/collections.html
+[counter-dicts]: https://docs.python.org/3/library/collections.html#collections.Counter
+[ordered-dicts-docs]: https://docs.python.org/3/library/collections.html#collections.OrderedDict
+[default-dicts]: https://docs.python.org/2/library/collections.html#collections.defaultdict

concepts/dicts/links.json

@@ -0,0 +1,34 @@
+[
+  {
+    "url": "https://docs.python.org/3/glossary.html#term-hashable",
+    "description": "term-hashable"
+  },
+  {
+    "url": "https://docs.python.org/3/library/stdtypes.html#mapping-types-dict",
+    "description": "mapping-types-dict"
+  },
+  {
+    "url": "https://docs.python.org/3/tutorial/datastructures.html#dictionaries",
+    "description": "dicts-docs"
+  },
+  {
+    "url": "https://www.w3schools.com/python/python_dictionaries.asp",
+    "description": "how-to"
+  },
+  {
+    "url": "https://docs.python.org/3/library/collections.html",
+    "description": "collections-docs"
+  },
+  {
+    "url": "https://docs.python.org/3/library/collections.html#collections.Counter",
+    "description": "counter-dicts"
+  },
+  {
+    "url": "https://docs.python.org/3/library/collections.html#collections.OrderedDict",
+    "description": "ordered-dicts-docs"
+  },
+  {
+    "url": "https://docs.python.org/2/library/collections.html#collections.defaultdict",
+    "description": "default-dicts"
+  }
+]

exercises/concept/inventory-management/.docs/after.md

@@ -1 +1,28 @@
-# TO DO
+## General
+
+- [The Python Dictionary Tutorial](https://docs.python.org/3/tutorial/datastructures.html#dictionaries) can be a great introduction.
+
+## 1. Create the dictionary
+
+- You need a [for loop](https://docs.python.org/3/tutorial/controlflow.html#for-statements) to iterate the list of items, then insert each item in the dictionary if missing and increment the item count using the dictionary accessor.
+- You can use [`setdefault`](https://www.w3schools.com/python/ref_dictionary_setdefault.asp) to make sure the value is set before incrementing the count of the item.
+- This function should [return a dict](https://www.w3schools.com/python/ref_keyword_return.asp).
+
+## 2. Add items to a dictionary
+
+- You need a [for loop](https://docs.python.org/3/tutorial/controlflow.html#for-statements) to iterate the list of items, then insert each item if not already in the dictionary and [increment](https://www.w3schools.com/python/gloss_python_assignment_operators.asp) the item count using the dictionary accessor.
+- You can use [`setdefault`](https://www.w3schools.com/python/ref_dictionary_setdefault.asp) to make sure the value is set before incrementing the count of the item.
+- The function `add_items` can be used by the `create_inventory` function with an empty dictionary in parameter.
+- This function should [return a dict](https://www.w3schools.com/python/ref_keyword_return.asp).
+
+## 3. Delete items from a dictionary
+
+- You need [for loop](https://docs.python.org/3/tutorial/controlflow.html#for-statements) to iterate the list of items, if the number of items is not `0` then [decrement](https://www.w3schools.com/python/gloss_python_assignment_operators.asp) the current number of items.
+- You can use the `key in dict` that returns `True` if the key exists to make sure the value is in the dictionary before decrementing the number of items.
+- This function should [return a dict](https://www.w3schools.com/python/ref_keyword_return.asp).
+
+## 4. List the items that are in stock
+
+- You need [for loop](https://docs.python.org/3/tutorial/controlflow.html#for-statements) on the inventory and if the number of item is greater of `0` then append the tuple to a list.
+- You can use `dict.items()` to iterate on both the item and the value at the same time, `items()` returns a tuple that you can use as it is or deconstruct.
+- This function should [return](https://www.w3schools.com/python/ref_keyword_return.asp) a [list](https://docs.python.org/3/tutorial/introduction.html#lists) of [tuples](https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences).

exercises/concept/inventory-management/.docs/hints.md

@@ -1,12 +1,14 @@
-In this exercise you'll be managing an inventory system.
+In this exercise, you will be managing an inventory system.
 
-You will be given a list of items. Each time an item is in the given list, add `1` to the key in the _given_ inventory. Each item should be organized by their name and the amount of that item. You will also have to delete items from the inventory.
+The inventory should be organized by the item name and it should keep track of the number of items available.
 
-You will also have to implement a function which returns a list of `tuples` of all the key-value pairs in the _given_ inventory.
+You will have to handle adding items to an inventory. Each time an item appears in a given list, increase the item's quantity by `1` in the inventory. Then, you will have to handle deleting items from an inventory.
 
-## 1. Create an inventory from a list
+To finish, you will have to implement a function which returns all the key-value pairs in an inventory as a list of `tuples`.
 
-Implement the `create_inventory()` function that creates an "inventory" from a list of items. It should return a `dictionary` representing the types and amounts of the items.
+## 1. Create an inventory based on a list
+
+Implement the `create_inventory()` function that creates an "inventory" from a list of items. It should return a `dict` containing each item name paired with their respective quantity.
 
 ```python
 >>> create_inventory(["coal", "wood", "wood", "diamond", "diamond", "diamond"])
@@ -15,7 +17,7 @@ Implement the `create_inventory()` function that creates an "inventory" from a l
 
 ## 2. Add items from a list to an existing dictionary
 
-Implement the `add_items()` function that adds a list of items to a passed in inventory dictionary:
+Implement the `add_items()` function that adds a list of items to an inventory:
 
 ```python
 >>> add_items({"coal":1}, ["wood", "iron", "coal", "wood"])
@@ -24,14 +26,14 @@ Implement the `add_items()` function that adds a list of items to a passed in in
 
 ## 3. Remove items from the inventory
 
-Implement the `delete_items()` function that removes items in the passed-in list from the passed inventory dictionary:
+Implement the `delete_items()` function that removes every item in the list from an inventory:
 
 ```python
 >>> delete_items({"coal":3, "diamond":1, "iron":5}, ["diamond", "coal", "iron", "iron"])
 {"coal":2, "diamond":0, "iron":3}
 ```
 
-Item counts should not fall below `0`, if the amount of an item in the list exceeds the amount of items in the inventory, the value should stop at `0` and not go into negative numbers.
+Item counts should not fall below `0`, if the number of items in the list exceeds the number of items available in the inventory, the listed quantity for that item should remain at `0` and the request for removing that item should be ignored.
 
 ```python
 >>> delete_items({"coal":2, "wood":1, "diamond":2}, ["coal", "coal", "wood", "wood", "diamond"])
@@ -40,9 +42,9 @@ Item counts should not fall below `0`, if the amount of an item in the list exce
 
 ## 4. Return the inventory content
 
-Implement the `list_inventory()` function that takes an inventory and returns a list of `(item, amount)` tuples. Only include items where the amount is greater than zero:
+Implement the `list_inventory()` function that takes an inventory and returns a list of `(item, quantity)` tuples. The list should only include the available items (with a quantity greater than zero):
 
 ```python
->>> list_inventory({"coal":7, "wood":11, "diamond":2, "iron":7, "silver": 0})
+>>> list_inventory({"coal":7, "wood":11, "diamond":2, "iron":7, "silver":0})
 [('coal', 7), ('diamond', 2), ('iron', 7), ('wood', 11)]
 ```

exercises/concept/inventory-management/.docs/instructions.md

@@ -1,75 +1,65 @@
 ## dicts
 
-A _dictionary_ is Python's primary mapping type that connects _hashable keys_ with values. The looking up of keys is more efficient than searching through an array, but does require more memory.
+A _**dictionary**_ is Python's primary mapping type that associates a _hashable key_ with a value. The lookup by key is more efficient than searching through an array, but does require more memory.
 
 ## Dict construction
 
-Dictionaries can be created in various ways. You can either use the `dict()` class constructor or the literal declaration of a _dict_.
+Dictionaries can be created in various ways. Two simple options are the use the `dict()` class constructor or the dict literal declaration with key-value pairs.
 
 ### Use the `dict()` constructor
 
 ```python
->>> bear = dict(name="Black Bear", amount=5, land_animal=True)
-{'name': 'Panda', 'amount': 15, 'land_animal': True}
+>>> bear = dict(name="Black Bear", speed=40, land_animal=True)
+{'name': 'Black Bear', 'speed': 40, 'land_animal': True}
 ```
 
 ### Declare a _dict_ literal
 
 ```python
->>> whale = {"name":"Blue Whale", "amount":2, "land_animal":False}
-{'name': 'Dolphin', 'amount': 2, 'land_animal': False}
+>>> whale = {"name": "Blue Whale", "speed": 35, "land_animal": False}
+{'name': 'Blue Whale', 'speed': 35, 'land_animal': False}
 ```
 
-With literal declaration keep in mind that _keys_ are replaced with _data types_ and the `=` is replaced with a `:`.
+With the dict literal declaration keep in mind that _keys_ are of _data types_ `str` and the colon `:` is used instead of an equal sign `=`.
 
 ## Accessing values
 
-You can access items in a dictionary in two ways, using the _key_ of the value.
+You can access an item in a dictionary using the _key_ of the value.
 
 ### Using _square brackets_ after the dict object
 
 ```python
->>> request_brackets = bear["amount"]
-5
+>>> bear["speed"]
+40
 ```
 
 ### Using `.get()`
 
 ```python
->>> request_get = whale.get("name")
-Blue Whale
+>>> whale.get("name")
+'Blue Whale'
 ```
 
 ## Changing values
 
-You can easily change a value of an item using it's _key_.
+You can easily change a value of an item using its _key_.
 
 ```python
 >>> bear["name"] = "Grizzly Bear"
-{'name': 'Grizzly Bear', 'amount': 5, 'land_animal': True}
+{'name': 'Grizzly Bear', 'speed': 40, 'land_animal': True}
 
->>> whale["amount"] = 7
-{'name': 'Blue Whale', 'amount': 7, 'land_animal': False}
+>>> whale["speed"] = 25
+{'name': 'Blue Whale', 'speed': 25, 'land_animal': False}
 ```
 
 ## Looping through a dictionary
 
-Looping through a dictionary using a `for` loop only returns the _keys_ of the items.
+Looping through a dictionary using `for item in dict` will iterate over the _keys_, but you can access the _values_ by using _square brackets_.
 
 ```python
 >>> for key in bear:
->>>     print(key)
-name
-amount
-land_animal
-```
-
-But you can also make a `for` loop return the _values_ of a dictionary with a simple trick.
-
-```python
->>> for key in whale:
->>>    print(whale[key])
-Blue Whale
-7
-False
+>>>     (key, bear[key])
+('name', 'Black Bear')
+('speed', 40)
+('land_animal', True)
 ```

exercises/concept/inventory-management/.docs/introduction.md

@@ -5,6 +5,16 @@
       "exercism_username": "j08k"
     }
   ],
+  "contributors": [
+    {
+      "github_username": "valentin-p",
+      "exercism_username": "valentin-p"
+    },
+    {
+      "github_username": "bethanyG",
+      "exercism_username": "bethanyG"
+    }
+  ],
   "editor": {
     "solution_files": ["dicts.py"],
     "test_files": ["dicts_test.py"]

exercises/concept/inventory-management/.meta/config.json

@@ -4,7 +4,7 @@
 
 The goal of this exercise is to teach the basics of the `dict` (dictionary, mapping) data type in Python.
 
-## Things to teach
+## Learning objectives
 
 - create a `dict` via constructor and literal.
 - access values in a `dict` via `keys`.
@@ -15,7 +15,7 @@ The goal of this exercise is to teach the basics of the `dict` (dictionary, mapp
 - iterate through a `dict` using `dict.keys()`, `dict.values()`, or `dict.items()`.
 - `dict` method `setdefault()`
 
-## Things not to teach
+## Out of scope
 
 - Dictionary comprehensions
 - `dict` methods such as `get()` or `clear()`.

exercises/concept/inventory-management/.meta/design.md

@@ -13,8 +13,8 @@ def add_items(inventory, items):
 
 def delete_items(inventory, items):
     for item in items:
-        inventory.setdefault(item, 0)
-        inventory[item] = max(inventory[item] - 1, 0)
+        if item in inventory:
+            inventory[item] = max(inventory[item] - 1, 0)
     return inventory
 
 

exercises/concept/inventory-management/.meta/example.py

@@ -1,11 +1,14 @@
 def create_inventory(items):
     pass
 
+
 def add_items(inventory, items):
     pass
 
+
 def delete_items(inventory, items):
     pass
 
+
 def list_inventory(inventory):
     pass