Iterating over an Object’s Attributes in Python
If you’re a Python developer, chances are that you’ve come across situations where you need to iterate over an object’s attributes. This could be in the context of debugging, testing, or trying to better understand the workings of a module or class.
Fortunately, Python provides a number of ways to access an object’s attributes and values. In this article, we’ll explore three popular techniques for iterating over an object’s attributes in Python, starting with the __dict__ attribute.
Using __dict__ Attribute to Get Attributes and Values
One way to access an object’s attributes and their respective values is to use the __dict__ attribute. In Python, every object has a __dict__ attribute that returns a dictionary containing the object’s attributes and their values.
The __dict__ attribute provides a simple way to inspect an object’s state, as shown in the example below. “`
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
person = Person(‘Charlie’, 28)
print(person.__dict__)
“`
In this example, we define a `Person` class with two instance variables `name` and `age`.
We then create an instance of the `Person` class and print out its __dict__ attribute. The output of running this code is:
“`
{‘name’: ‘Charlie’, ‘age’: 28}
“`
As you can see, the __dict__ attribute returns a dictionary containing the object’s attributes and their corresponding values.
This technique works equally well for built-in types, such as strings and integers.
Using vars() Function to Get Attributes and Values
Another way to access an object’s attributes and values is to use the built-in `vars()` function. The `vars()` function takes an argument that can be either an object or a module and returns a dictionary of its attributes and their respective values.
Here’s an example. “`
class Car:
brand = ‘Ford’
model = ‘Mustang’
year = 2022
car = Car()
print(vars(car))
“`
In this example, we define a `Car` class with three class variables `brand`, `model`, and `year`. We then create an instance of the `Car` class and print out its attributes using the `vars()` function.
The output of running this code is:
“`
{‘brand’: ‘Ford’, ‘model’: ‘Mustang’, ‘year’: 2022}
“`
As you can see, the `vars()` function returns a dictionary with the object’s attributes and values, just like the __dict__ attribute. However, the `vars()` function is more flexible since it can also be used to get the attributes and values of modules, as shown in the example below.
“`
import math
print(vars(math))
“`
In this example, we import the `math` module and use the `vars()` function to get its attributes and values. The output of running this code is a dictionary with the module’s attributes and values.
Using dir() Function to Get Attributes and Values
The third way to access an object’s attributes and values is to use the built-in `dir()` function. The `dir()` function returns a list of attributes and methods of an object.
Here’s an example. “`
class BankAccount:
def __init__(self, balance):
self.balance = balance
def deposit(self, amount):
self.balance += amount
def withdraw(self, amount):
self.balance -= amount
account = BankAccount(1000)
print(dir(account))
“`
In this example, we define a `BankAccount` class with two methods `deposit()` and `withdraw()`. We then create an instance of the `BankAccount` class and print out its attributes and methods using the `dir()` function.
The output of running this code is:
“`
[‘__class__’, ‘__delattr__’, ‘__dict__’, ‘__dir__’, ‘__doc__’, ‘__eq__’, ‘__format__’, ‘__ge__’, ‘__getattribute__’,
‘__gt__’, ‘__hash__’, ‘__init__’, ‘__init_subclass__’, ‘__le__’, ‘__lt__’, ‘__module__’, ‘__ne__’, ‘__new__’,
‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘__weakref__’,
‘balance’, ‘deposit’, ‘withdraw’]
“`
As you can see, the `dir()` function returns a list of all the object’s attributes and methods. However, the list can be overwhelming since it also includes built-in and special attributes.
Filtering Out Attributes that Start with Two Underscores
When using the `dir()` function, you may notice that some of the attributes start with two underscores. These attributes are special attributes that are used by Python and should not be modified.
To exclude these attributes from the list returned by the `dir()` function, you can filter them out using a list comprehension, as shown in this example. “`
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
pass
animal = Animal(‘Dog’)
attrs = [attr for attr in dir(animal) if not attr.startswith(‘__’)]
print(attrs)
“`
In this example, we define an `Animal` class with one instance variable `name` and one method `speak()`. We then create an instance of the `Animal` class and use a list comprehension to filter out the special attributes that start with two underscores.
The output of running this code is:
“`
[‘name’, ‘speak’]
“`
As you can see, the resulting list only contains the `Animal` instance variable and method, and excludes the special attributes.
Excluding Methods from Attributes
When iterating over an object’s attributes, you may want to exclude its methods from the list of attributes since they are not really attributes. To do this, you can check whether each attribute is a callable function using the built-in `callable()` function.
Here’s an example. “`
class Rectangle:
length = 10
width = 5
def area(self):
return self.length * self.width
def perimeter(self):
return 2 * (self.length + self.width)
rect = Rectangle()
attrs = [attr for attr in dir(rect) if not callable(getattr(rect, attr))]
print(attrs)
“`
In this example, we define a `Rectangle` class with two class variables `length` and `width`, and two methods `area()` and `perimeter()`. We then create an instance of the `Rectangle` class and use a list comprehension to filter out the callable functions using `callable()`.
The output of running this code is:
“`
[‘length’, ‘width’]
“`
As you can see, the resulting list only contains the class variables and not the methods.
Iterating Only Over Class Variables
Sometimes you may want to iterate only over the class variables and not the instance variables or methods. One way to accomplish this is by using the `vars()` function to get the class dictionary and then filtering out the instance variables and methods.
Here’s an example. “`
class Book:
category = ‘Fiction’
author = ‘J.K. Rowling’
def __init__(self, title):
self.title = title
book = Book(‘Harry Potter and the Philosopher’s Stone’)
attrs = [attr for attr in vars(Book) if not callable(getattr(Book, attr)) and not attr.startswith(‘__’)]
print(attrs)
“`
In this example, we define a `Book` class with two class variables `category` and `author`, and one instance variable `title`. We then use the `vars()` function to get the class dictionary and filter out the callable functions and special attributes using a list comprehension.
The output of running this code is:
“`
[‘category’, ‘author’]
“`
As you can see, the resulting list only contains the class variables and not the instance variable or methods.
Conclusion
In this article, we explored three popular techniques for iterating over an object’s attributes in Python. We started with the __dict__ attribute, which provides a dictionary of an object’s attributes and values.
Next, we looked at the vars() function, which can be used to get attributes and values of both objects and modules. Finally, we covered the dir() function, which returns a list of an object’s attributes and methods.
By using some additional filtering techniques, we were able to get more targeted lists of attributes and values that were useful for debugging, testing, and understanding the workings of a module or class. In sum, iterating over an object’s attributes in Python is crucial for debugging, testing, and understanding how a module or class works.
Three popular techniques for accessing an object’s attributes were explored: __dict__ attribute, vars() function, and dir() function. Filtering techniques were also discussed, including filtering out attributes that start with two underscores, excluding methods from attributes, and iterating only over class variables.
By understanding these techniques, Python developers can efficiently iterate over an object’s attributes and ultimately become more proficient in their work.