Python：重構模式

攝影：Patric Ho

這份簡明指南將 Python 程式碼氣味對應到對應的設計模式解決方案。

<code class="language-python">class CodeSmellSolutions:
    DUPLICATED_CODE = [
        "form_template_method",
        "introduce_polymorphic_creation_with_factory_method",
        "chain_constructors",
        "replace_one__many_distinctions_with_composite",
        "extract_composite",
        "unify_interfaces_with_adapter",
        "introduce_null_object",
    ]
    LONG_METHOD = [
        "compose_method",
        "move_accumulation_to_collecting_parameter",
        "replace_conditional_dispatcher_with_command",
        "move_accumulation_to_visitor",
        "replace_conditional_logic_with_strategy",
    ]
    CONDITIONAL_COMPLEXITY = [  # Complex conditional logic
        "replace_conditional_logic_with_strategy",
        "move_emblishment_to_decorator",
        "replace_state_altering_conditionals_with_state",
        "introduce_null_object",
    ]
    PRIMITIVE_OBSESSION = [
        "replace_type_code_with_class",
        "replace_state_altering_conditionals_with_state",
        "replace_conditional_logic_with_strategy",
        "replace_implict_tree_with_composite",
        "replace_implicit_language_with_interpreter",
        "move_emblishment_to_decorator",
        "encapsulate_composite_with_builder",
    ]
    INDECENT_EXPOSURE = [  # Lack of information hiding
        "encapsulate_classes_with_factory"
    ]
    SOLUTION_SPRAWL = [  # Scattered logic/responsibility
        "move_creation_knowledge_to_factory"
    ]
    ALTERNATIVE_CLASSES_WITH_DIFFERENT_INTERFACES = [  # Similar classes, different interfaces
        "unify_interfaces_with_adapter"
    ]
    LAZY_CLASS = [  # Insufficient functionality
        "inline_singleton"
    ]
    LARGE_CLASS = [
        "replace_conditional_dispatcher_with_command",
        "replace_state_altering_conditionals_with_state",
        "replace_implict_tree_with_composite",
    ]
    SWITCH_STATEMENTS = [  # Complex switch statements
        "replace_conditional_dispatcher_with_command",
        "move_accumulation_to_visitor",
    ]
    COMBINATION_EXPLOSION = [  # Similar code for varying data
        "replace_implicit_language_with_interpreter"
    ]
    ODDBALL_SOLUTIONS = [  # Multiple solutions for same problem
        "unify_interfaces_with_adapter"
    ]</code>

Python 中的重構範例

專案將重構範例從 Refactoring to Patterns (Joshua Kerievsky) 翻譯成 Python。每個範例都顯示原始和重構的程式碼，突出顯示改進。 重構過程涉及解釋 UML 圖並使 Java 程式碼適應 Python 的細微差別（處理循環導入和介面）。

範例：撰寫方法

「Compose Method」重構透過擷取更小、更有意義的方法來簡化複雜的程式碼。

<code class="language-python"># Original (complex) code
def add(element):
    readonly = False
    size = 0
    elements = []
    if not readonly:
        new_size = size + 1
        if new_size > len(elements):
            new_elements = []
            for i in range(size):
                new_elements[i] = elements[i]  # Potential IndexError
            elements = new_elements
        size += 1
        elements[size] = element # Potential IndexError

# Refactored (simplified) code
def is_at_capacity(new_size, elements):
    return new_size > len(elements)

def grow_array(size, elements):
    new_elements = [elements[i] for i in range(size)] # List comprehension for clarity
    return new_elements

def add_element(elements, element, size):
    elements.append(element) # More Pythonic approach
    return len(elements) -1

def add_refactored(element):
    readonly = False
    if readonly:
        return
    size = len(elements)
    new_size = size + 1
    if is_at_capacity(new_size, elements):
        elements = grow_array(size, elements)
    size = add_element(elements, element, size)

</code>

範例：多態性（測試自動化）

此範例示範了測試自動化中的多態性，抽象化了測試設定以實現可重複使用性。

<code class="language-python"># Original code (duplicate setup)
class TestCase:
    pass

class DOMBuilder:
    def __init__(self, orders): pass
    def calc(self): return 42

class XMLBuilder:
    def __init__(self, orders): pass
    def calc(self): return 42

class DOMTest(TestCase):
    def run_dom_test(self):
        expected = 42
        builder = DOMBuilder("orders")
        assert builder.calc() == expected

class XMLTest(TestCase):
    def run_xml_test(self):
        expected = 42
        builder = XMLBuilder("orders")
        assert builder.calc() == expected

# Refactored code (polymorphic setup)
class OutputBuilder:
    def calc(self): raise NotImplementedError

class DOMBuilderRefac(OutputBuilder):
    def calc(self): return 42

class XMLBuilderRefac(OutputBuilder):
    def calc(self): return 42

class TestCaseRefac:
    def create_builder(self): raise NotImplementedError
    def run_test(self):
        expected = 42
        builder = self.create_builder()
        assert builder.calc() == expected

class DOMTestRefac(TestCaseRefac):
    def create_builder(self): return DOMBuilderRefac()

class XMLTestRefac(TestCaseRefac):
    def create_builder(self): return XMLBuilderRefac()
</code>

範例：訪客模式

訪客模式將類別與其方法解耦。

<code class="language-python"># Original code (conditional logic in TextExtractor)
class Node: pass
class LinkTag(Node): pass
class Tag(Node): pass
class StringNode(Node): pass

class TextExtractor:
    def extract_text(self, nodes):
        result = []
        for node in nodes:
            if isinstance(node, StringNode): result.append("string")
            elif isinstance(node, LinkTag): result.append("linktag")
            elif isinstance(node, Tag): result.append("tag")
            else: result.append("other")
        return result

# Refactored code (using Visitor)
class NodeVisitor:
    def visit_link_tag(self, node): return "linktag"
    def visit_tag(self, node): return "tag"
    def visit_string_node(self, node): return "string"

class Node:
    def accept(self, visitor): pass

class LinkTagRefac(Node):
    def accept(self, visitor): return visitor.visit_link_tag(self)

class TagRefac(Node):
    def accept(self, visitor): return visitor.visit_tag(self)

class StringNodeRefac(Node):
    def accept(self, visitor): return visitor.visit_string_node(self)

class TextExtractorVisitor(NodeVisitor):
    def extract_text(self, nodes):
        result = [node.accept(self) for node in nodes]
        return result
</code>

結論

這種透過重構學習設計模式的實用方法可以顯著增強理解。 翻譯程式碼時遇到的挑戰鞏固了理論知識。

以上是Python：重構模式的詳細內容。更多資訊請關注PHP中文網其他相關文章！