Index

Important

Web version availabe at: https://sbugallo.github.io/mastering_python

PDF version available at: https://github.com/sbugallo/mastering_python/raw/master/python.pdf

Errata reports, mistakes or contributions: https://github.com/sbugallo/mastering_python

• Craftmanship
  • Strings and bytes
    • 1. Implementation details
    • 2. String concatenation
    • 3. String formatting with f-strings
  • Python’s protocols: dunder methods and attributes
  • Sequences
    • 1. Creating your own sequences
  • Context managers
    • 1. Implementing context managers
  • Iterable objects
    • 1. Creating iterable objects
    • 2. Creating sequences
  • Container objects
    • 1. Lists and tuples
    • 2. Dictionaries
    • 3. Sets
    • 4. Supplemental data types and containers
    • 5. Custom containers
  • Dynamic attributes for objects
  • Callable objects
  • Docstrings and annotations
    • 1. Docstrings
    • 2. Annotations
  • Caveats in Python
    • 1. Mutable default arguments
    • 2. Extending built-in types
  • General traits of good code
    • 1. Design by contract
    • 2. Defensive programming
    • 3. Separation of concerns
    • 4. Acronyms to live by
    • 5. Composition and inheritance
    • 6. Arguments in functions and methods
    • 7. Final remarks on good practices for software design
  • SOLID
    • 1. Single responsibility principle
    • 2. The open/closed principle
    • 3. Liskov’s substitution principle
    • 4. Interface segregation
    • 5. Dependency inversion
  • Decorators
    • 1. What are decorators?
    • 2. Effective decorators: avoid common mistakes
    • 3. The DRY principle with decorators
    • 4. Decorators and separation of concerns
    • 5. Analyzing good decorators
  • Properties, attributes and methods for objects
    • 1. Underscores in Python
    • 2. Properties
    • 3. Slots
  • Data classes
  • Descriptors
    • 1. A first look at descriptors
    • 2. Types of descriptors
    • 3. Descriptors in action
    • 4. Analysis of descriptors
  • Generators
    • 1. Creating generators
    • 2. Iterating idiomatically
    • 3. Coroutines
    • 4. Asynchronous programming
  • MRO and accessing methods from superclasses
    • 1. Old-style classes and super in Python 2
    • 2. Understanding Python’s Method Resolution Order
    • 3. Super pitfalls
    • 4. Best practices
  • Metaprogramming
    • 1. What is metaprogramming
    • 2. Decorators
    • 4. Using __new__() for overriding instantiation
    • 5. Metaclasses
    • 6. Code generation
  • Naming
    • 1. PEP 8
    • 2. Naming styles
    • 3. Naming guide
    • 4. Best practices for arguments
    • 5. Class names
    • 6. Modules and packages
    • 7. Useful tools
• Data structures and algorithms
• Code quality
  • Documenting your project
    • 1. The seven rules of technical writing
    • 2. Documentation as code
    • 3. Popular documentation generators
    • 4. Documenting web APIs
    • 5. Building a well-organized documentation system
  • Unit testing and refactoring
    • 1. Design principles and unit testing
    • 2. Frameworks and tools for testing
    • 3. Refactoring
    • 4. More about unit testing
    • 5. A brief introduction to test-driven development
• Code optimization
• Technical architecture
  • Design patterns
    • 1. Considerations for design patterns in Python
    • 2. Design patterns in action
    • 3. The null object pattern
    • 4. Final thoughts about design patterns
  • Clean architecture
    • 1. From clean code to clean architecture
    • 2. Software components
    • 3. Use case
• Low level Python
  • How does Python work?
    • 1. Interpreters
  • Modern Python Development Environments
    • 1. Installing packages with pip
    • 2. Isolating the runtime environment
    • 3. Popular productivity tools
• Code distribution
  • Packaging
    • 1. Creating a package
    • 2. Namespace packages
    • 3. Uploading a package
    • 4. Standalone executables
  • Deployment
    • 1. The Twelve-factor app
    • 2. Approaches to deployment automation
    • 3. Index mirroring
    • 4. Common conventions and practices
    • 5. Code instrumentation and monitoring
• References