Robust Codeを書くためのプログラミング姿勢について

1
A robust codebase is resilient and error-free in spite of constant change.

stateDiagram
    direction LR
    Clean --> Readable
    Readable --> Understanble
    maintainable --> Improvable
    Understanble --> Improvable
    Improvable   --> Robust

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Take a meal recipe and change the number of servings
# by adjusting each ingredient
# A recipe's first element is the number of servings, and the remainder
# of elements is (name, amount, unit), such as ("flour", 1.5, "cup")
def adjust_recipe(recipe, servings):
    new_recipe = [servings]
    old_servings = recipe[0]
    factor = servings / old_servings
    recipe.pop(0)
    while recipe:
        ingredient, amount, unit = recipe.pop(0)
        # please only use numbers that will be easily measurable
        new_recipe.append((ingredient, amount * factor, unit))
    return new_recipe

1
2
3
4
5
6
7
def adjust_recipe(recipe, servings):
    old_servings = recipe.pop(0)
    factor = servings / old_servings
    new_recipe = {ingredient: (amount*factor, unit)
                  for ingredient, amount, unit in recipe}
    new_recipe["servings"] = servings
    return new_recipe

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def adjust_recipe(recipe, servings):
    """
    Take a meal recipe and change the number of servings
    :param recipe: a `Recipe` indicating what needs to be adusted
    :param servings: the number of servings
    :return Recipe: a recipe with serving size and ingredients adjusted
                    for the new servings
    """
    # create a copy of the ingredients
    new_ingredients = list(recipe.get_ingredients())
    recipe.clear_ingredients()

    for ingredient in new_ingredients:
            ingredient.adjust_proportion(Fraction(servings, recipe.servings))
    return Recipe(servings, new_ingredients)

1
2
3
4
5
6
7
def create_author_count_mapping(cookbooks: list[Cookbook]):
    counter = {}
    for cookbook in cookbooks:
        if cookbook.author not in counter:
            counter[cookbook.author] = 0
        counter[cookbook.author] += 1
    return counter

1
2
3
4
5
6
7
8
9
10
11
12
## defaultdict
from collections import defaultdict
def create_author_count_mapping(cookbooks: list[Cookbook]):
    counter = defaultdict(lambda: 0)
    for cookbook in cookbooks:
        counter[cookbook.author] += 1
    return counter

## Counter
from collections import Counter
def create_author_count_mapping(cookbooks: list[Cookbook]):
    return Counter(book.author for book in cookbooks)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 過度な抽象化: a + bで十分
class MathOperations:
    def add(self, a, b):
        return a + b

result = MathOperations().add(3, 4)


# Excessive Configuration: 普通にpackageを使おう
class DatabaseConnector:
    def __init__(self, host, port, username, password):
        # ... complex configuration code ...

    def connect(self):
        # ... complex connection logic ...

# Using the complex database connector
db = DatabaseConnector(host='localhost', port=5432, username='user', password='pass')
db.connect()


# 不必要な前処理の実施: 統計処理に不必要な前処理を担当したクラスの実装
class AdvancedDataProcessor:
    def __init__(self, data):
        # ... complex initialization ...

    def process_data(self):
        # ... complex data processing ...

# Using an overly complex data processor
data_processor = AdvancedDataProcessor(data)
data_processor.process_data()

統計 Python math Linux Ubuntu 20.04 LTS Shell English git Ubuntu 22.04 LTS 方法論 統計検定 競技プログラミング フーリエ解析 前処理 SQL coding 将棋 Data visualization Network statistical inference VSCode apt システム管理 Coffee Docker Econometrics GitHub Pages cloud 数値計算 素数 Book Font Metrics Poetry architecture aws shell ssh systemctl テンプレート データ構造 ポワソン分布 会計分析 文字コード 環境構築 論文 App Bayesian Dynamic Programming Keyboard Processing R Steam filesystem regex