amontalenti/elements-of-python-style

Features

• Code Style Guides - Provides a comprehensive set of standards for naming, formatting, and layout to ensure consistent Python code readability.
• Coding Standards - Offers a comprehensive set of opinionated coding standards and formatting rules for Python.
• Python Coding Standards - Establishes comprehensive standards for naming conventions, module organization, and project layout to ensure codebase consistency.
• Software Design - Provides insights into system architecture and domain modeling by choosing between functional patterns, mixins, and modules.
• Documentation Standards - Establishes technical standards for docstrings and markup to facilitate automated API documentation.
• Style Guides - Supplies opinionated guidelines for writing clean, maintainable, and idiomatic Python code.
• Functional Design Patterns - Promotes a functional-first architecture using pure functions and stateless components to reduce complexity.
• Functional Programming - Encourages the application of functional paradigms such as pure functions and generators for side-effect-free code.
• Python Patterns - Provides a set of opinionated architectural patterns focusing on functional and declarative programming to reduce complexity.
• Code Documentation Standards - Offers technical standards for writing docstrings and markup to ensure clear API descriptions.
• Coupling Reduction Strategies - Advocates for using built-in types instead of custom objects to minimize coupling.
• Naming Conventions - Defines standardized naming conventions and casing styles for consistent identifier usage.
• Project Layout Standards - Establishes conventions for directory structures, initialization files, and build scripts to ensure consistency across repositories.
• Duck Typing Patterns - Advocates for duck typing to achieve flexible polymorphism without rigid inheritance trees.
• Exception Handling Strategies - Implements patterns for catching and logging runtime errors to prevent silent failures and ensure stability.
• Functionality Module Organizations - Provides standards for organizing functionality into isolated modules and packages to reduce architectural complexity.
• Project Structure Organization - Defines systems for dividing source code into separate folders and sub-projects to manage dependencies and portability.
• Project Structure Standardization - Provides shared file patterns and directory groups to ensure consistent project layout for source code and distribution.
• Project Structures - Defines standardized layouts and organizational patterns for project directories and dependency management.
• Software Architecture Design - Provides architectural principles and patterns for building maintainable and modular software systems using functional and declarative paradigms.
• Data Interface Design - Promotes the use of simple, serializable types for arguments and return values to reduce object coupling.
• Error Handling - Standardizes error recovery by using specific built-in exception types and prohibiting bare catch clauses.
• Docstrings - Establishes standards for writing docstrings that describe function parameters and return values for automated tools.
• Metaprogramming - Offers guidelines on using decorators, descriptors, and context managers to customize object behavior via metaprogramming.
• Technical Documentation Drafting - Provides standards for drafting concise, one-line docstrings to improve the maintainability of reusable functions.
• API Documentation - Defines technical specifications and interface descriptions for software libraries via standardized docstrings.
• Interface-Based Decoupling - Recommends using built-in serializable types to decouple components from custom object dependencies.
• Context Managers - Provides guidelines for using context managers to ensure reliable resource cleanup and exception handling.
• Metaprogramming - Details the use of decorators and descriptors for flexible framework customization through metaprogramming.
• Standard Directory Layouts - Provides a recommended directory skeleton for organizing source code and managing dependencies for better portability.
• Visibility Access Controls - Explains the use of underscores to mark internal members and control variable visibility.
• Behavioral Mixins - Provides guidance on using mixins to share behaviors across different class hierarchies.
• General Purpose Mixins - Explains how to use mixins to share behavior without creating deep inheritance chains.
• Declarative Programming Patterns - Guides the use of declarative patterns to simplify how code expresses its intended logic.
• Python Exception Patterns - Implements safe exception management and resource handling via context managers.
• Error Handling Strategies - Implements architectural strategies for robust failure detection and safe resource cleanup using Python exceptions.
• Instance Verification Patterns - Recommends instance verification over direct type matching to correctly handle subclasses.
• Language Style Guides - Guidelines for writing clean and readable Python code.
• Python Language Resources - Guidelines and best practices for writing idiomatic Python code.

Star history