How to Retrieve Named Parameters Passed to a Constructor in Python constructor, named parameters

A comprehensive guide on how to get named parameters passed into a Python constructor, without including default parameters. Learn how to achieve this functionality using the `__new__` method.
---

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Is it possible to get list of parameters passed into a constructor?

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding Named Parameters in Python Constructors

When working with Python classes, it's often necessary to know which named parameters have been explicitly passed to a constructor. This is especially useful when you want to distinguish between default parameters and those that are supplied during instantiation.

For example, consider the class A shown in the code snippet below:

[[See Video to Reveal this Text or Code Snippet]]

In the instantiation of a1, there are no named parameters provided, while a2 includes explicit values for p1 and p3. The challenge here is to retrieve only the named parameters that have been passed during instantiation, while ignoring those that have default values.

The Challenge

a1 should result in {} because it was instantiated without any parameters.

a2 should return {'p1': 2, 'p3': 'blah'} as those are the parameters passed.

Unfortunately, using built-in functions like inspect won't achieve this, as they return all parameters, including defaults. Additionally, using locals() inside the constructor also mirrors all parameters and does not filter out defaults.

The Solution

To overcome this challenge, we can utilize the __new__ method to intercept the arguments being passed. Here's how you can implement it:

Step 1: Modify the Class

In your class, you need to define the __new__ method, which allows you to capture the keyword arguments passed during instantiation.

[[See Video to Reveal this Text or Code Snippet]]

Step 2: Instantiating the Class

Now, whenever you create an instance of class A, the __new__ method will print the keyword arguments being passed:

[[See Video to Reveal this Text or Code Snippet]]

Explanation

The *args captures positional arguments while **kwargs captures named parameters when creating an instance of a class.

The print statement within __new__ effectively outputs only the passed parameters, enabling you to manage what you receive from the constructor.

Conclusion

Retrieving only the named parameters passed to a constructor in Python is not straightforward but can be accomplished through the __new__ method. This method efficiently filters out optional parameters with default values, allowing for better control over instance creation. By using this approach, you can enhance your classes and ensure they behave as expected, focusing solely on user-inputted values.

Hopefully, this solution clarifies how to achieve your goal. If you have any further questions or need additional help, feel free to ask!