piglei/one-python-craftsman

Features

• Idiomatic Patterns - A comprehensive guide to Python-specific coding patterns and idiomatic conventions that improve professional code quality.
• Python Best Practices - Serves as a comprehensive collection of Python-specific idioms, best practices, and professional coding techniques.
• Python Language Features - Covers fundamental Python syntax, internal object models, and core language features.
• Type Annotations - Provides guidance on adding type descriptions to function arguments and return values for static type checking.
• Python Patterns - Provides Python-specific architectural patterns including data-driven design and dependency injection.
• Dependency Injection - Implements dependency injection to pass behavioral strategies into objects during initialization.
• EAFP Error Handling - Advocates and demonstrates the EAFP philosophy for robust and idiomatic Python error management.
• Engineering Best Practices - Implements professional development workflows and industry-standard practices for software development.
• EAFP Patterns - Implements the EAFP pattern to manage boundary cases and missing data efficiently in Python.
• Dependency Injection - Provides a comprehensive guide on decoupling software components by injecting required behavioral dependencies during initialization.
• Object-Oriented Design Principles - Implements SOLID principles and other object-oriented design patterns to ensure maintainable and scalable software.
• Precise Exception Handling - Provides capabilities for robust error management by capturing specific exceptions and maintaining architectural abstraction consistency.
• Refactoring Techniques - Offers strategies for improving the structure and readability of existing Python code through refactoring.
• Large Scale Architectures - Offers architectural insights and experience-based guidance for developing and managing complex, large-scale Python projects.
• Object Oriented Design - Provides guidance on applying object-oriented design principles and patterns to structure Python software systems.
• Data-Driven Architectural Patterns - Provides an architectural approach that externalizes changing logic into data structures.
• Software Engineering Principles - Guidance on applying software engineering principles like SOLID and precise error handling to Python projects.
• Iterable Decoration - Provides patterns for wrapping source iterables in generators to handle filtering and indexing efficiently.
• Assignment Expressions - Covers the use of the walrus operator to eliminate redundancy in conditional statements and comprehensions.
• Class Inheritance - Provides detailed guidance on using class inheritance to extend and override behavior in Python.
• Efficient Container Selection - Guides the selection of optimal Python collection types, such as sets and deques, to enhance performance.
• Starred Sequence Unpackings - Provides guidance on using starred expressions and nested unpacking to distribute iterable elements into variables.
• Idiomatic Loop Construction - Teaches advanced techniques for increasing iteration efficiency through idiomatic loop decomposition and generator modifiers.
• Literal and Constant Management - Guides the handling of constants and text using enumerations, raw strings, and advanced formatting techniques.
• Loop Flattening - Shows how to replace multi-layer nested loops with a single loop using Cartesian products for better readability.
• Magic Method Implementations - Demonstrates how to implement magic methods to customize object slicing, string formatting, and data class behavior.
• Predicate-Based Iteration Limits - Implements patterns to automatically terminate loops based on specific conditions, replacing manual break statements.
• Custom Iterators - Explains how to implement the iterator protocol using magic methods to create custom traversal sequences.
• Single Element Retrieval - Demonstrates efficient retrieval of the first matching element from a collection without converting iterables to lists.
• Slicing Iteration - Explains how to extract elements from an iterable at specific intervals without loading the full sequence into memory.
• Class-Based Decorators - Provides detailed strategies for implementing class-based decorators to extend function behavior in an object-oriented manner.
• Coding Best Practices - Shares engineering patterns and technical tips to improve code quality and efficiency across Python functions.
• Generator-Based Iterators - Demonstrates the use of the yield keyword to create lazy iterables and reduce iterator boilerplate.
• Configuration-Driven Logic - Implements patterns for representing executable logic as structured data to allow behavior modification without altering source code.
• Decorators - Extends function behavior using class-based decorators while preserving original metadata.
• Interface-Implementation Separation - Teaches the separation of functional interfaces from implementation details to improve code maintainability and modularity.
• Nested Loop Extractions - A Python refactoring technique that wraps nested loops in a separate function to allow immediate exit via a single return.
• Performance Optimization Patterns - Details performance optimization patterns such as efficient iterator use and container selection to reduce memory usage.
• Generator-Based Data Pipelines - Separates the logic of fetching data from processing it using decoupled generator-based pipelines.
• Generator-Based Pipelines - Demonstrates how to construct decoupled data pipelines using generators to isolate acquisition from processing.
• Refactoring Techniques - Provides a practice for splitting large classes and functions into specialized components to minimize reasons for change.

Star history