Metaprogramming with Python

Book description

A practical approach to metaprogramming with real-world examples that enables the development of advanced frameworks, libraries, and applications using Python

Key Features

  • Learn applied metaprogramming through a simple step-by-step approach
  • Work with easily understandable examples and explanations that take you deep into the theory of metaprogramming
  • Get practical experience in writing reusable code with real-world examples

Book Description

Effective and reusable code makes your application development process seamless and easily maintainable. With Python, you will have access to advanced metaprogramming features that you can use to build high-performing applications.

The book starts by introducing you to the need and applications of metaprogramming, before navigating the fundamentals of object-oriented programming. Next, you will learn about simple decorators, work with metaclasses, and later focus on introspection and reflection. You'll also delve into generics and typing before defining templates for algorithms. As you progress, you will understand your code using abstract syntax trees and explore method resolution order. This Python book also shows you how to create your own dynamic objects before structuring the objects through design patterns. Finally, you will learn simple code-generation techniques along with discovering best practices and eventually building your own applications.

By the end of this learning journey, you'll have acquired the skills and confidence you need to design and build reusable high-performing applications that can solve real-world problems.

What you will learn

  • Understand the programming paradigm of metaprogramming and its need
  • Revisit the fundamentals of object-oriented programming
  • Define decorators and work with metaclasses
  • Employ introspection and reflection on your code
  • Apply generics, typing, and templates to enhance your code
  • Get to grips with the structure of your code through abstract syntax trees and the behavior through method resolution order
  • Create dynamic objects and generate dynamic code
  • Understand various design patterns and best practices

Who this book is for

If you are an intermediate-level Python programmer looking to enhance your coding skills by developing reusable and advanced frameworks, then this book is for you. Basic knowledge of Python programming will help you get the most out of this learning journey.

Publisher resources

Download Example Code

Table of contents

  1. Metaprogramming with Python
  2. Contributors
  3. About the author
  4. About the reviewers
  5. Preface
    1. Who this book is for
    2. What this book covers
    3. To get the most out of this book
    4. Download the example code files
    5. Download the color images
    6. Conventions used
    7. Get in touch
    8. Share Your Thoughts
  6. Part 1: Fundamentals – Introduction to Object-Oriented Python and Metaprogramming
  7. Chapter 1: The Need for and Applications of Metaprogramming
    1. Technical requirements
    2. An overview of metaprogramming
      1. Metaprogramming – a practical introduction
      2. Metadata of the add function
      3. Resolving type errors using metaprogramming
    3. Understanding why we need metaprogramming
      1. Don’t Repeat Yourself
    4. Exploring the applications of metaprogramming
    5. Summary
  8. Chapter 2: Refresher of OOP Concepts in Python
    1. Technical requirements
    2. Introducing our core example
    3. Creating classes
    4. Understanding objects
    5. Applying methods
    6. Implementing inheritance
    7. Extending to multiple inheritance
    8. Understanding polymorphism
      1. Polymorphism within inheritance
      2. Polymorphism in independent classes
    9. Hiding details with abstraction
    10. Protecting information with encapsulation
      1. Private members
      2. Protected members
    11. Summary
  9. Part 2: Deep Dive – Building Blocks of Metaprogramming I
  10. Chapter 3: Understanding Decorators and their Applications
    1. Technical requirements
    2. Looking into simple function decorators
      1. Understanding function decorators with an application
    3. Exchanging decorators from one function to another
    4. Applying multiple decorators to one function
    5. Exploring class decorators
      1. Understanding class decorators with an application
    6. Getting to know built-in decorators
      1. The static method
      2. The class method
    7. Summary
  11. Chapter 4: Working with Metaclasses
    1. Technical requirements
    2. Overview of metaclasses
    3. The structure of a metaclass
      1. Analyzing the arguments
    4. The application of metaclasses
      1. Inheriting the metaclass
      2. Inheriting as a parent and metaclass
    5. Switching metaclasses
    6. Inheritance in metaclasses
    7. Manipulating class variables
    8. Summary
  12. Chapter 5: Understanding Introspection
    1. Technical requirements
    2. Introducing built-in functions
    3. Using the built-in id function
    4. Debugging unintentional assignments using id
    5. Finding out whether an object is callable
    6. Checking whether an object has an attribute
    7. Checking whether an object is an instance
    8. Checking whether an object is a subclass
    9. Understanding the usage of property
    10. Using property as a decorator
    11. Summary
  13. Chapter 6: Implementing Reflection on Python Objects
    1. Technical requirements
    2. Introducing built-in functions used in reflection
    3. Using id to delete duplicates
    4. Using callable to dynamically check and generate methods
    5. Using hasattr to set values
    6. Using isinstance to modify an object
    7. Using issubclass to modify a class
    8. Applying property on a class
    9. Summary
  14. Chapter 7: Understanding Generics and Typing
    1. Technical requirements
    2. What are generics?
      1. How are generics connected to metaprogramming?
      2. How are generics handled in Python?
    3. What happens when data types are specified?
      1. Type hints as annotations
    4. Typing with explicit type checks – approach 1
      1. Creating a class to implement type checking
      2. Creating a class to test type checking
    5. Typing with explicit type checks – approach 2
      1. Creating a class to implement type checking
      2. Creating a class to test type checking
    6. Adding data types with constraints
    7. Creating a simple custom data type
    8. Creating a domain-specific data type
    9. Summary
  15. Chapter 8: Defining Templates for Algorithms
    1. Technical requirements
    2. Explaining a sequence of operations
      1. Back to our core example
      2. The vegetables and dairy counter
      3. Less than 10 items counter
      4. The greater than 10 items counter
      5. Electronics counter
    3. Defining the sequence of methods
      1. The vegetable counter
      2. Less than 10 items counter
      3. Greater than 10 items counter
      4. The electronics counter
    4. Identifying the common functionalities
    5. Designing templates
    6. Summary
  16. Part 3: Deep Dive – Building Blocks of Metaprogramming II
  17. Chapter 9: Understanding Code through Abstract Syntax Tree
    1. Technical requirements
    2. Exploring the ast library
    3. Inspecting Python code with abstract syntax trees
      1. Reviewing simple code using ast
      2. Modifying simple code using ast
    4. Understanding abstract syntax trees with applications
      1. Understanding the ast of a class
      2. Modifying the ast of a code block by parsing
      3. Modifying the ast of a code block by transforming nodes
    5. Summary
  18. Chapter 10: Understanding Method Resolution Order of Inheritance
    1. Technical requirements
    2. Understanding the MRO of a class
      1. Understanding MRO in single inheritance
      2. Understanding MRO in multiple inheritances
      3. Reviewing MRO in multilevel inheritance
    3. Understanding the importance of modifying the order of inheritance
    4. Impact of unintended change of order in inheritance
    5. Summary
  19. Chapter 11: Creating Dynamic Objects
    1. Technical requirements
    2. Exploring type for dynamic objects
    3. Creating multiple instances of a class dynamically
    4. Creating dynamic classes
      1. Creating multiple dynamic classes
    5. Creating dynamic attributes and methods
      1. Defining attributes dynamically
      2. Defining methods dynamically
    6. Summary
  20. Chapter 12: Applying GOF Design Patterns – Part 1
    1. Technical requirements
    2. An overview of design patterns
    3. Exploring behavioral design patterns
      1. Understanding the chain of responsibility
      2. Learning about the command design pattern
      3. The strategy design pattern
    4. Summary
  21. Chapter 13: Applying GOF Design Patterns – Part 2
    1. Technical requirements
    2. Exploring structural design patterns
      1. Understanding the bridge pattern
      2. Understanding the facade pattern
      3. Understanding the proxy pattern
    3. Exploring creational design patterns
      1. Understanding the factory method
      2. Understanding the prototype method
      3. Understanding the singleton pattern
    4. Summary
  22. Chapter 14: Generating Code from AST
    1. Technical requirements
    2. Generating a simple class with a template
    3. Generating multiple classes from a list
    4. Generating a class with attributes
    5. Generating a class with methods
      1. Generating a class with an init method
      2. Generating a class with a user-defined method
    6. Defining a custom class factory
    7. Developing a code generator to generate a simple library
    8. Summary
  23. Chapter 15: Implementing a Case Study
    1. Technical requirements
    2. Explaining the case study
    3. Defining base classes
    4. Developing a code generator library
    5. Generating code
    6. Designing an execution framework
    7. Summary
  24. Chapter 16: Following Best Practices
    1. Technical requirements
    2. Following PEP 8 standards
      1. Indentation
      2. Neat representation
    3. Writing clear comments for debugging and reusability
    4. Adding documentation strings
      1. Documentation string for metaprogramming
    5. Naming conventions
      1. Class names
      2. Variables
      3. Functions and methods
    6. Avoiding the reuse of names
    7. Avoiding metaprogramming where not required
    8. Summary
    9. Why subscribe?
  25. Other Books You May Enjoy
    1. Packt is searching for authors like you
    2. Share Your Thoughts

Product information

  • Title: Metaprogramming with Python
  • Author(s): Sulekha AloorRavi
  • Release date: September 2022
  • Publisher(s): Packt Publishing
  • ISBN: 9781838554651