Python Refactoring and Code Quality

  1. Basic Refactoring Techniques
    1. Naming and Organization Refactoring
      1. Rename Variable
        1. Improving Variable Clarity
          1. Avoiding Name Shadowing
            1. Scope-Appropriate Naming
            2. Rename Function and Method
              1. Descriptive Function Naming
                1. Verb-Noun Naming Patterns
                  1. API Consistency
                  2. Rename Class
                    1. Reflecting Class Responsibility
                      1. Noun-Based Class Names
                        1. Avoiding Generic Names
                        2. Move Function
                          1. Relocating to Appropriate Modules
                            1. Maintaining Import Compatibility
                            2. Move Method
                              1. Finding Better Method Homes
                                1. Preserving Object Relationships
                              2. Method Composition Refactoring
                                1. Extract Method
                                  1. Identifying Extractable Code Blocks
                                    1. Improving Code Reusability
                                      1. Parameter Passing Strategies
                                      2. Extract Function
                                        1. Creating Standalone Functions
                                          1. Reducing Method Complexity
                                            1. Pure Function Extraction
                                            2. Inline Method
                                              1. Removing Unnecessary Abstractions
                                                1. Simplifying Call Chains
                                                2. Inline Function
                                                  1. Eliminating Trivial Functions
                                                  2. Replace Temp with Query
                                                    1. Eliminating Temporary Variables
                                                      1. Direct Calculation in Expressions
                                                        1. Performance Considerations
                                                      2. Conditional Logic Simplification
                                                        1. Decompose Conditional
                                                          1. Breaking Down Complex Boolean Logic
                                                            1. Extracting Condition Methods
                                                              1. Improving Readability
                                                              2. Consolidate Conditional Expression
                                                                1. Combining Similar Conditions
                                                                  1. Reducing Duplication in Logic
                                                                  2. Replace Nested Conditional with Guard Clauses
                                                                    1. Early Return Patterns
                                                                      1. Reducing Nesting Levels
                                                                        1. Improving Code Flow
                                                                        2. Remove Control Flag
                                                                          1. Eliminating Boolean State Variables
                                                                            1. Using Break and Continue Effectively
                                                                          2. Function Call Simplification
                                                                            1. Introduce Parameter Object
                                                                              1. Creating Data Transfer Objects
                                                                                1. Reducing Parameter Lists
                                                                                2. Preserve Whole Object
                                                                                  1. Passing Objects Instead of Attributes
                                                                                    1. Reducing Parameter Coupling
                                                                                    2. Replace Parameter with Method Call
                                                                                      1. Calculating Parameters Internally
                                                                                        1. Reducing External Dependencies

                                                                                    Previous

                                                                                    3. Code Quality Tools and Automation

                                                                                    Go to top

                                                                                    Next

                                                                                    5. Object-Oriented Refactoring