Merge pull request #3 from kokesak/ch3

Chapter 3: data structures

Author: kokesak

days/07-09-data-structures/code/day8/cars.py

@@ -0,0 +1,62 @@
+from typing import Dict, List
+
+cars = {
+    'Ford': ['Falcon', 'Focus', 'Festiva', 'Fairlane'],
+    'Holden': ['Commodore', 'Captiva', 'Barina', 'Trailblazer'],
+    'Nissan': ['Maxima', 'Pulsar', '350Z', 'Navara'],
+    'Honda': ['Civic', 'Accord', 'Odyssey', 'Jazz'],
+    'Jeep': ['Grand Cherokee', 'Cherokee', 'Trailhawk', 'Trackhawk']
+}
+DEFAULT_SEARCH = "trail"
+CarsType = Dict[str, List[str]]
+
+
+def get_all_jeeps(cars: CarsType = cars) -> str:
+    """
+    Retrieve the 'Jeep' models from the cars dict and join them by a
+    comma and space (', '). Leave the original ordering intact.
+    """
+    ret_str = cars['Jeep'][0]
+    for car in cars['Jeep'][1:]:
+        ret_str += ", " + car
+    return ret_str
+
+def get_first_model_each_manufacturer(cars: CarsType = cars) -> List[str]:
+    """
+    Loop through the cars dict filtering out the first model for each
+    manufacturer. Return the matching models in a list leaving the original
+    ordering intact.
+    """
+    ret_list = []
+    for manf in cars.values():
+        ret_list.append(manf[0])
+    return ret_list
+
+
+def get_all_matching_models(
+    cars: CarsType = cars, grep: str = DEFAULT_SEARCH
+) -> List[str]:
+    """
+    Return a list of all models containing the case insensitive
+    'grep' string which defaults to DEFAULT_SEARCH ('trail').
+    Sort the resulting sequence alphabetically
+    """
+    ret_list = []
+    for models in cars.values():
+        for car in models:
+            if grep.lower() in car.lower():
+                ret_list.append(car)
+
+    return sorted(ret_list)
+
+
+def sort_car_models(cars: CarsType = cars) -> CarsType:
+    """
+    Loop through the cars dict returning a new dict with the
+    same keys and the values sorted alphabetically.
+    """
+    sorted_dict = {}
+    for manuf, models in cars.items():
+        sorted_dict[manuf] = sorted(models)
+
+    return sorted_dict

days/07-09-data-structures/code/day8/test_cars.py

@@ -0,0 +1,40 @@
+from cars import (get_all_jeeps, get_first_model_each_manufacturer,
+                  get_all_matching_models, sort_car_models)
+
+
+def test_get_all_jeeps():
+    expected = 'Grand Cherokee, Cherokee, Trailhawk, Trackhawk'
+    actual = get_all_jeeps()
+    assert type(actual) == str
+    assert actual == expected
+
+
+def test_get_first_model_each_manufacturer():
+    actual = get_first_model_each_manufacturer()
+    expected = ['Falcon', 'Commodore', 'Maxima', 'Civic', 'Grand Cherokee']
+    assert actual == expected
+
+
+def test_get_all_matching_models_default_grep():
+    expected = ['Trailblazer', 'Trailhawk']
+    assert get_all_matching_models() == expected
+
+
+def test_get_all_matching_models_different_grep():
+    expected = ['Accord', 'Commodore', 'Falcon']
+    assert get_all_matching_models(grep='CO') == expected
+
+
+def test_sort_dict_alphabetically():
+    actual = sort_car_models()
+    # Order of keys should not matter, two dicts are equal if they have the
+    # same keys and the same values.
+    # The car models (values) need to be sorted here though
+    expected = {
+        'Ford': ['Fairlane', 'Falcon', 'Festiva', 'Focus'],
+        'Holden': ['Barina', 'Captiva', 'Commodore', 'Trailblazer'],
+        'Honda': ['Accord', 'Civic', 'Jazz', 'Odyssey'],
+        'Jeep': ['Cherokee', 'Grand Cherokee', 'Trackhawk', 'Trailhawk'],
+        'Nissan': ['350Z', 'Maxima', 'Navara', 'Pulsar'],
+    }
+    assert actual == expected

days/07-09-data-structures/code/day9/states.py

@@ -0,0 +1,74 @@
+us_state_abbrev = {'Alabama': 'AL', 'Alaska': 'AK', 'Arizona': 'AZ',
+                   'Arkansas': 'AR', 'California': 'CA', 'Colorado': 'CO',
+                   'Connecticut': 'CT', 'Delaware': 'DE', 'Florida': 'FL',
+                   'Georgia': 'GA', 'Hawaii': 'HI', 'Idaho': 'ID',
+                   'Illinois': 'IL', 'Indiana': 'IN', 'Iowa': 'IA',
+                   'Kansas': 'KS', 'Kentucky': 'KY', 'Louisiana': 'LA',
+                   'Maine': 'ME', 'Maryland': 'MD', 'Massachusetts': 'MA',
+                   'Michigan': 'MI', 'Minnesota': 'MN', 'Mississippi': 'MS',
+                   'Missouri': 'MO', 'Montana': 'MT', 'Nebraska': 'NE',
+                   'Nevada': 'NV', 'New Hampshire': 'NH', 'New Jersey': 'NJ',
+                   'New Mexico': 'NM', 'New York': 'NY',
+                   'North Carolina': 'NC', 'North Dakota': 'ND',
+                   'Ohio': 'OH', 'Oklahoma': 'OK', 'Oregon': 'OR',
+                   'Pennsylvania': 'PA', 'Rhode Island': 'RI',
+                   'South Carolina': 'SC', 'South Dakota': 'SD',
+                   'Tennessee': 'TN', 'Texas': 'TX', 'Utah': 'UT',
+                   'Vermont': 'VT', 'Virginia': 'VA', 'Washington': 'WA',
+                   'West Virginia': 'WV', 'Wisconsin': 'WI', 'Wyoming': 'WY'}
+
+states = ['Oklahoma', 'Kansas', 'North Carolina', 'Georgia', 'Oregon',
+          'Mississippi', 'Minnesota', 'Colorado', 'Alabama',
+          'Massachusetts', 'Arizona', 'Connecticut', 'Montana',
+          'West Virginia', 'Nebraska', 'New York', 'Nevada', 'Idaho',
+          'New Jersey', 'Missouri', 'South Carolina', 'Pennsylvania',
+          'Rhode Island', 'New Mexico', 'Alaska', 'New Hampshire',
+          'Tennessee', 'Washington', 'Indiana', 'Hawaii', 'Kentucky',
+          'Virginia', 'Ohio', 'Wisconsin', 'Maryland', 'Florida',
+          'Utah', 'Maine', 'California', 'Vermont', 'Arkansas', 'Wyoming',
+          'Louisiana', 'North Dakota', 'South Dakota', 'Texas',
+          'Illinois', 'Iowa', 'Michigan', 'Delaware']
+
+NOT_FOUND = 'N/A'
+
+
+def get_every_nth_state(states=states, n=10):
+    """Return a list with every nth item (default argument n=10, so every
+       10th item) of the states list above (remember: lists keep order)"""
+    return states[n-1::n]
+
+
+def get_state_abbrev(state_name, us_state_abbrev=us_state_abbrev):
+    """Look up a state abbreviation by querying the us_state_abbrev
+       dict by full state name, for instance 'Alabama' returns 'AL',
+       'Illinois' returns 'IL'.
+       If the state is not in the dict, return 'N/A' which we stored
+       in the NOT_FOUND constant (takeaway: dicts are great for lookups)"""
+    try:
+        result = us_state_abbrev[state_name]
+    except KeyError:
+        result = NOT_FOUND
+    return result
+
+
+def get_longest_state(data):
+    """Receives data, which can be the us_state_abbrev dict or the states
+       list (see above). It returns the longest state measured by the length
+       of the string"""
+    return max(data, key=len)
+
+
+
+def combine_state_names_and_abbreviations(us_state_abbrev=us_state_abbrev,
+                                          states=states):
+    """Get the first 10 state abbreviations ('AL', 'AK', 'AZ', ...) from
+       the us_state_abbrev dict, and the last 10 states from the states
+       list (see above) and combine them into a new list. The resulting list
+       has both sorted, so:
+       ['AK', 'AL', 'AZ', ..., 'South Dakota', 'Tennessee', 'Texas', ...]
+       (see also test_combine_state_names_and_abbreviations)"""
+    result = []
+    result = list(us_state_abbrev.values())[:10] + list(us_state_abbrev.keys())[-10:]
+    return sorted(result)
+
+print(get_every_nth_state())

days/07-09-data-structures/code/day9/test_states.py

@@ -0,0 +1,33 @@
+from states import (get_every_nth_state, get_state_abbrev,
+                    get_longest_state, combine_state_names_and_abbreviations,
+                    states, us_state_abbrev, NOT_FOUND)
+
+
+def test_get_every_nth_state():
+    expected = ['Massachusetts', 'Missouri', 'Hawaii',
+                'Vermont', 'Delaware']
+    assert list(get_every_nth_state()) == expected
+    expected = ['Missouri', 'Vermont']
+    assert list(get_every_nth_state(n=20)) == expected
+
+
+def test_get_state_abbrev():
+    assert get_state_abbrev('Illinois') == 'IL'
+    assert get_state_abbrev('North Dakota') == 'ND'
+    assert get_state_abbrev('bogus') == NOT_FOUND
+
+
+def test_get_longest_state():
+    # depending the direction of the sort (reversed or not)
+    # both North and South Carolina are correct
+    possible_answers = ('North Carolina', 'South Carolina')
+    assert get_longest_state(us_state_abbrev) in possible_answers
+    assert get_longest_state(states) in possible_answers
+
+
+def test_combine_state_names_and_abbreviations():
+    expected = ['AK', 'AL', 'AR', 'AZ', 'CA', 'CO', 'CT', 'DE', 'FL', 'GA',
+                'South Dakota', 'Tennessee', 'Texas', 'Utah',
+                'Vermont', 'Virginia', 'Washington', 'West Virginia',
+                'Wisconsin', 'Wyoming']
+    assert combine_state_names_and_abbreviations() == expected