Book Image

Metaprogramming with Python

By : Sulekha AloorRavi
Book Image

Metaprogramming with Python

By: Sulekha AloorRavi

Overview of this book

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.

Related Content you might be interested in

Current Title:

Small book image
Metaprogramming with Python
Sulekha AloorRavi
Sep, 2022 | 402 pages
No titles found
Table of Contents (21 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Download the color images
Conventions used
Get in touch
Share Your Thoughts
1
Part 1: Fundamentals – Introduction to Object-Oriented Python and Metaprogramming
Part 1: Fundamentals – Introduction to Object-Oriented Python and Metaprogramming
Free Chapter
2
Chapter 1: The Need for and Applications of Metaprogramming
Chapter 1: The Need for and Applications of Metaprogramming
Technical requirements
An overview of metaprogramming
Understanding why we need metaprogramming
Exploring the applications of metaprogramming
Summary
3
Chapter 2: Refresher of OOP Concepts in Python
Chapter 2: Refresher of OOP Concepts in Python
Technical requirements
Introducing our core example
Creating classes
Understanding objects
Applying methods
Implementing inheritance
Extending to multiple inheritance
Understanding polymorphism
Hiding details with abstraction
Protecting information with encapsulation
Summary
4
Part 2: Deep Dive – Building Blocks of Metaprogramming I
Part 2: Deep Dive – Building Blocks of Metaprogramming I
5
Chapter 3: Understanding Decorators and their Applications
Chapter 3: Understanding Decorators and their Applications
Technical requirements
Looking into simple function decorators
Exchanging decorators from one function to another
Applying multiple decorators to one function
Exploring class decorators
Getting to know built-in decorators
Summary
6
Chapter 4: Working with Metaclasses
Chapter 4: Working with Metaclasses
Technical requirements
Overview of metaclasses
The structure of a metaclass
The application of metaclasses
Switching metaclasses
Inheritance in metaclasses
Manipulating class variables
Summary
7
Chapter 5: Understanding Introspection
Chapter 5: Understanding Introspection
Technical requirements
Introducing built-in functions
Using the built-in id function
Debugging unintentional assignments using id
Finding out whether an object is callable
Checking whether an object has an attribute
Checking whether an object is an instance
Checking whether an object is a subclass
Understanding the usage of property
Using property as a decorator
Summary
8
Chapter 6: Implementing Reflection on Python Objects
Chapter 6: Implementing Reflection on Python Objects
Technical requirements
Introducing built-in functions used in reflection
Using id to delete duplicates
Using callable to dynamically check and generate methods
Using hasattr to set values
Using isinstance to modify an object
Using issubclass to modify a class
Applying property on a class
Summary
9
Chapter 7: Understanding Generics and Typing
Chapter 7: Understanding Generics and Typing
Technical requirements
What are generics?
What happens when data types are specified?
Typing with explicit type checks – approach 1
Typing with explicit type checks – approach 2
Adding data types with constraints
Creating a simple custom data type
Creating a domain-specific data type
Summary
10
Chapter 8: Defining Templates for Algorithms
Chapter 8: Defining Templates for Algorithms
Technical requirements
Explaining a sequence of operations
Defining the sequence of methods
Identifying the common functionalities
Designing templates
Summary
11
Part 3: Deep Dive – Building Blocks of Metaprogramming II
Part 3: Deep Dive – Building Blocks of Metaprogramming II
12
Chapter 9: Understanding Code through Abstract Syntax Tree
Chapter 9: Understanding Code through Abstract Syntax Tree
Technical requirements
Exploring the ast library
Inspecting Python code with abstract syntax trees
Understanding abstract syntax trees with applications
Summary
13
Chapter 10: Understanding Method Resolution Order of Inheritance
Chapter 10: Understanding Method Resolution Order of Inheritance
Technical requirements
Understanding the MRO of a class
Understanding the importance of modifying the order of inheritance
Impact of unintended change of order in inheritance
Summary
14
Chapter 11: Creating Dynamic Objects
Chapter 11: Creating Dynamic Objects
Technical requirements
Exploring type for dynamic objects
Creating multiple instances of a class dynamically
Creating dynamic classes
Creating dynamic attributes and methods
Summary
15
Chapter 12: Applying GOF Design Patterns – Part 1
Chapter 12: Applying GOF Design Patterns – Part 1
Technical requirements
An overview of design patterns
Exploring behavioral design patterns
Summary
16
Chapter 13: Applying GOF Design Patterns – Part 2
Chapter 13: Applying GOF Design Patterns – Part 2
Technical requirements
Exploring structural design patterns
Exploring creational design patterns
Summary
17
Chapter 14: Generating Code from AST
Chapter 14: Generating Code from AST
Technical requirements
Generating a simple class with a template
Generating multiple classes from a list
Generating a class with attributes
Generating a class with methods
Defining a custom class factory
Developing a code generator to generate a simple library
Summary
18
Chapter 15: Implementing a Case Study
Chapter 15: Implementing a Case Study
Technical requirements
Explaining the case study
Defining base classes
Developing a code generator library
Generating code
Designing an execution framework
Summary
19
Chapter 16: Following Best Practices
Chapter 16: Following Best Practices
Technical requirements
Following PEP 8 standards
Writing clear comments for debugging and reusability
Adding documentation strings
Naming conventions
Avoiding the reuse of names
Avoiding metaprogramming where not required
Summary
Why subscribe?
20
Other Books You May Enjoy
Other Books You May Enjoy
Packt is searching for authors like you
Share Your Thoughts

Generating a simple class with a template

In this section, we will be looking at how to generate code for a class without actually defining the class itself. We will be creating a string-based template with the structure of a class we want to develop but not the actual code that can be executed. To explain this further, let us look at an example where we will generate a class named VegCounter by parsing a series of strings using the ast module.

The sequence of steps to be followed to generate code for a class is represented in the following flow diagram:

Figure 14.1 – A code generation sequence for a simple class

Let us look at the implementation of this example:

  1. We will start by importing the ast library:
    import ast
  2. Let us now create a variable to pass the class name with which the code needs to be generated:
    classname = "VegCounter"
  3. We will next define a variable that becomes the template for the class generated in this...
Previous Section
End of Section 3
Next Section