What is Python vars() Function?

Python vars() is a built-in function that you can utilize to access an object’s attributes and their values with ease. It’s especially handy when you’re working with instances of custom classes, providing a straightforward way to inspect and manipulate attributes. However, it’s important to keep in mind that vars() may not work with certain built-in types or objects that don’t have a __dict__ attribute. Additionally, it doesn’t grant access to attributes inherited from parent classes.

To get a better concept, imagine you’re managing a database of employees in a human resources system. Each employee is represented as an object of a custom Employee class, which has attributes like name, ID, department, and salary. You need to perform various operations on these employee objects, and you decide to use the vars() function to simplify your tasks.

Now with a foundational grasp of the Python vars() function, let’s progress and delve into its syntax and parameters. Understanding these aspects holds significant importance when it comes to applying this function in practical scenarios. Now, let’s explore these aspects through practical examples to enhance your understanding.

Python vars() Syntax and Parameter

The syntax of the vars() function is pleasantly uncomplicated. Let’s examine this more closely:

vars(object)

While utilizing Python vars(), remember that it accepts a single argument: the object you wish to examine or extract attributes from. This object can take various forms, including an instance of a class, a module, or any other object possessing attributes that you intend to access.

Now that you have a good grasp of the syntax and parameters of Python vars(), let’s examine its return value to gain insight into how this function operates in real-world examples.

Python vars() Return Value

Python vars() returns a dictionary containing the attributes (names and values) of an object. This dictionary allows you to manipulate the attributes dynamically. The keys in the dictionary represent attribute names, while the corresponding values are the attribute values associated with those name. Let’s examine this with an example:

Example Code
class Person: def __init__(self, name, age): self.name = name self.age = age tom = Person("Tom", 30) attributes = vars(tom) print(attributes)

Here, we define a Person class with name and age attributes. We create an instance of the Person class named tom, and then we use the vars() function to retrieve the object’s attributes, and then we use print() function to print the results on the screen. Then the output will be:

Output
{‘name’: ‘Tom’, ‘age’: 30}

As you can see in the above example, you can easily use Python vars() to inspect the attributes that has a __dict__ attribute, such as instances of custom classes like the Person class in this case.

As mentioned above, that the vars() function is employed to work with an object’s attributes. Now, let’s move forward and explore real-world examples to better grasp how Python’s vars() can be employed efficiently.

I. Python vars() Without Any Arguments

In Python, when you use the vars() function without any arguments, it returns the __dict__ attribute of the current scope. This means it provides access to the local symbol table, which contains the current scope’s variables, including global variables if you’re at the module level.

It essentially gives you a dictionary-like view of the current scope’s symbol table, allowing you to inspect and manipulate the variables within that scope. Here’s an example:

Example Code
def greet(name): message = "Hello, " + name local_vars = vars() return local_vars result = greet("Learners") print(result)

Here, we’ve defined a function called greet that takes a single argument, name. Inside the function, we create a message variable by concatenating the string Hello,  with the name argument, forming a personalized greeting message. Next, we use the vars() function without any arguments to capture the local variables within the greet function’s scope. This means it collects information about all the variables defined in that specific function at the moment of the vars() call.

Finally, we return these local variables as a dictionary-like object, and we store the result of the greet function in a variable called result. To illustrate how this works, we call the greet function with the argument Learners, creating a greeting message for learners. We then print the result, which will display a dictionary containing information about the local variables within the greet function’s scope at the time of the function call.

Output
{‘name’: ‘Learners’, ‘message’: ‘Hello, Learners’}

This above example is a simple illustration of how vars() can be used to inspect local variables within a specific function’s context.

II. Understanding vars() and Retrieving the __dict__ Attribute

Comprehending the concept of vars() and its relationship with retrieving the __dict__ attribute is crucial in Python. This understanding empowers you to dynamically interact with an object’s attributes. When you employ vars() on an object, it grants access to the __dict__ attribute of that object.

By grasping the inner workings of how vars() leverages the __dict__ attribute, you acquire a potent tool for dynamic attribute management and introspection within your Python code. Here’s a visualization:

Example Code
class MyNumber: def __init__(self, x, y): self.x = x self.y = y def inspect_object(obj): local_vars = vars(obj) return local_vars my_obj = MyNumber(10, 20) result = inspect_object(my_obj) print(result)

For this example, we have a class named MyNumber, which takes two arguments, x and y, in its constructor. Inside the constructor, these arguments are assigned to instance variables self.x and self.y. This class essentially represents a custom object that holds two numerical values.

We also define a function called inspect_object that takes an object obj as its parameter. Within this function, we use the vars() function to inspect the attributes of the object obj. vars() returns a dictionary containing the object’s attributes and their values.

Next, we create an instance of the MyNumber class named my_obj with the values 10 and 20 as its x and y attributes. Then, we call the inspect_object function, passing my_obj as an argument, which uses vars() to retrieve the attributes and their values of my_obj. Finally, we print the result, which will be a dictionary containing the attributes and values of the my_obj.

Output
{‘x’: 10, ‘y’: 20}

As evident from the example above, you can easily obtain the attributes within your code by employing the vars() function.

III. Modifying Object Attributes with vars()

Modifying object attributes with vars() enables you to change the values of an attributes using a dictionary-like interface. By retrieving an attribute with vars(obj), you can locate and modify specific attributes based on their names.

This capability is particularly useful when you need to alter object properties programmatically, such as updating configuration settings, adjusting object state during runtime, or performing dynamic data transformations. For instance:

Example Code
class Person: def __init__(self, name, age): self.name = name self.age = age def introduce(self): return f"Hi, I'm {self.name} and I'm {self.age} years old." person = Person("Harry", 20) print("Initial Attributes:") print(person.introduce()) if hasattr(person, 'name'): vars(person)['name'] = "Wedz" if hasattr(person, 'age'): vars(person)['age'] = 21 print("\nModified Attributes:") print(person.introduce())

In this example, First, we define the Person class with a method. Next, we have a method named introduce. This method returns a formatted string introducing the person with their name and age. We then create an instance of the Person class named person with the name Harry and age 20. We print Initial Attributes: to indicate that we’re displaying the initial attributes of the person object. We do this by calling the introduce method of the person object.

Now, here comes the interesting part. We use the hasattr function to check if the person object has attributes named ‘name‘ and ‘age‘. If it does, we use the vars() function to access the object’s __dict__ and change the values of name to Wedz and age to 21.

Finally, we print Modified Attributes: to indicate that we’re displaying the modified attributes of the person object. Again, we call the introduce method to generate and print a string.

Output
Initial Attributes:
Hi, I’m Harry and I’m 20 years old.

Modified Attributes:
Hi, I’m Wedz and I’m 21 years old.

In summary, this code showcases how to create a class, initialize attributes, modify those attributes using vars(), and then display the changes.

IV. Adding Object Attributes with vars()

The procedure of incorporating object attributes through vars() allows you to append fresh attributes to an object utilizing the vars() function. This becomes valuable when there’s a necessity to dynamically expand an attributes while the program is in execution.

By utilizing vars() you acquire the capacity to introduce brand-new attributes or adjust existing ones, offering adaptability in how you oversee object data, adapting it according to evolving demands or situations. For example:

Example Code
class PrimeNumber: def __init__(self, number): self.number = number prime_number = PrimeNumber(2) print(f"First Prime Number is: {prime_number.number}") print("\nAdding a new prime number: ") attributes = vars(prime_number) attributes['Prime Number'] = 7 attributes['Prime Number'] = 11 second_prime_number = attributes['Prime Number'] print(f"Second Prime Number is: {second_prime_number}") third_prime_number = attributes['Prime Number'] print(f"Third Prime Number is: {third_prime_number}")

For this example, we’ve created a class called PrimeNumber to work with prime numbers. We initialize the class with an instance variable number, which represents a prime number. We then create an instance of this class named prime_number and set its value to 2. We print out the value of this first prime number using an f-string.

Next, we use the vars() function to access the object’s attributes. We add a new attribute called Prime Number with a value of 7. We also update the Prime Number attribute to 11. We access and print the value of the Prime Number attribute twice to show that it has been updated.

Output
First Prime Number is: 2

Adding a new prime number:
Second Prime Number is: 11
Third Prime Number is: 11

With this fantastic method, you can easily include numbers or strings into an existing object by utilizing the vars() function.

V. Deleting Object Attributes with vars()

Deleting object attributes with vars() is a process that allows you to remove or delete specific attributes using the vars() function. This can be useful when you want to remove attributes from an object during runtime.

By accessing the object’s __dict__ using vars(), you gain the ability to manipulate its attributes, including deletion. It can be handy for cases where you need to manage and clean up object data or modify its structure based on certain conditions or requirements. To get a clear picture of this concept consider below illustration:

Example Code
class Book: def __init__(self, book_name, book_author): self.book_name = book_name self.book_author = book_author book = Book("Python Crash Course", "Eric Matthes") attributes = vars(book) del attributes['book_name'] try: print(f"Name of the book is: {book.book_name}") except AttributeError as e: print(f"Error: {e}")

Here, we have a class called Book. This class has an __init__ method that initializes two attributes: book_name and book_author, representing the name and author of a book. We create an instance of the Book class called book, and then we use the vars() function to access the object’s attributes and store them in the attributes dictionary. Next, we attempt to delete the book_name attribute from the attributes dictionary using del attributes[‘book_name‘].

After deleting the book_name attribute, we try to print the name of the book using book.book_name. However, since we’ve deleted the book_name attribute, it raises an AttributeError because the attribute no longer exists.

Output
Error: ‘Book’ object has no attribute ‘book_name’

As evident from the example above, attempting to utilize vars() for attribute deletion proves efficient and straightforward, as it allows not only access and modification of attributes but also their deletion.

Python vars() Advanced Examples

From this point, we will examine several advanced examples of Python vars() function, highlighting its flexibility and wide range of applications.

I. Python vars() with a Custom Object

Utilizing Python vars() with a custom object empowers you to gateway and control the attributes. When vars() is employed in conjunction with an object, it furnishes a dictionary comprising the attributes and their respective values.

It grants you the capability to introduce fresh attributes, modify existing ones, or retrieve their values, delivering flexibility in the management of object data. For instance:

Example Code
class Car: def __init__(self, make, model, year): self.make = make self.model = model self.year = year my_car = Car("Toyota", "Camry", 2022) car_attributes = vars(my_car) print(f"Make: {car_attributes['make']}") print(f"Model: {car_attributes['model']}") print(f"Year: {car_attributes['year']}") car_attributes['year'] = 2023 print(f"Updated Year: {car_attributes['year']}")

In this example, In our class called Car, we’ve defined an init method. When this method is called during object instantiation, it takes three parameters – make, model, and year, and assigns them as attributes to the object. We create an instance of this class named my_car and initialize it with the make Toyota, model Camry, and year 2022.

Next, we use the vars() function to access the attributes of the my_car object and store them in the car_attributes dictionary. We then print out the make, model, and year attributes of the car using this dictionary. Afterward, we modify the year attribute of the car to 2023 by directly accessing it through the car_attributes dictionary. Finally, we print the updated year attribute to confirm the change.

Output
Make: Toyota
Model: Camry
Year: 2022
Updated Year: 2023

The preceding example illustrates how you can use the vars() function to interact with custom objects, enabling easily access and modification of attributes.

II. Python vars() with Recursive Function

You can also perform recursive retrieve and modification of attributes within an object and its sub-objects (provided they have dict attributes) by implementing a custom recursive function.

This function traverses the object structure, utilizing vars() or similar techniques to access and edit attributes at various levels of the object hierarchy. Recursive programming entails creating a function that calls itself to process sub-components of the data structure. Here’s an illustration:

Example Code
class Information: def __init__(self): class Address_info: def __init__(self, street, city): self.street = street self.city = city class Person_info: def __init__(self, name, address): self.name = name self.address = address address = Address_info("123 Main St", "Cityville") person = Person_info("Harry", address) person_attributes = vars(person) address_attributes = vars(person_attributes['address']) print(f"Person Name: {person_attributes['name']}") print(f"Address Street: {address_attributes['street']}") print(f"Address City: {address_attributes['city']}") info = Information()

For this example, we have a class named Information. Within the constructor of the Information class, we’ve defined two inner classes: Address_info and Person_info. The Address_info class represents address details, containing attributes for the street and city. On the other hand, the Person_info class represents an individual and includes attributes such as their name and address. Notably, the address attribute in the Person_info class holds an instance of the Address_info class.

We then create instances of Address_info and Person_info with sample data. Subsequently, the vars() function is employed to access and retrieve attributes from these objects, specifically fetching the person’s name, street, and city. The values of these attributes are displayed using print() statements. To complete the code, we instantiate the Information class by creating an info object, which triggers the execution of the attribute retrieval and display.

Output
Person Name: Harry
Address Street: 123 Main St
Address City: Cityville

In summary, this example illustrates a structured approach to managing information about a person and their corresponding address, making use of nested classes and the vars() function.

III. Exception Handling with vars()

Exception handling with vars() refers to the practice of handling potential errors or exceptions that can occur when using the vars() function. When you use vars() to access an object’s attributes, there are situations where it might raise exceptions, especially if the you try to access non-existent attributes. For example:

Example Code
class CustomError(Exception): def __init__(self, message): super().__init__(message) class MyClass: def __init__(self): self.my_var = 42 try: obj = MyClass() attribute_name = 'non_existent_attribute' if attribute_name not in vars(obj): raise CustomError(f"Attribute '{attribute_name}' does not exist in the object.") attribute_value = vars(obj)[attribute_name] print("Attribute value:", attribute_value) except CustomError as e: print("Custom Error:", e) except Exception as e: print("An error occurred:", e) finally: print("Execution completed")

Here, we define a custom exception class CustomError. Inside the try block, we check if the attribute named ‘non_existent_attribute‘ exists in the object using if attribute_name not in vars(obj):, and if it doesn’t exist, we raise a CustomError with a specific error message.

Output
Custom Error: Attribute ‘non_existent_attribute’ does not exist in the object.
Execution completed

As illustrated in the above example, using vars() in conjunction with try-except is a straightforward method for managing exceptions and errors that may arise in your code.

Now that you’ve comprehensively grasped the Python vars() function, its uses, and its convenience and flexibility across various scenarios, you’ve established a strong foundation. Now, let’s explore some practical use-cases for Python vars() to enhance your understanding.

Practical Use Cases for vars()

Here are some practical ways you can use Python vars() in your programming journey:

I. Object Inspection

If you want to inspect the internal state of an object, vars() allows you to view and manipulate its attributes, which can be handy for debugging or introspection purposes.

II. Testing and Mocking

In testing scenarios, you can use vars() to inspect and modify an object’s attributes to set up specific test conditions or to create mock objects.

III. Data Validation and Sanitization

Python vars() can be used to validate or sanitize the data within an object’s attributes, making sure they meet certain criteria or formatting requirements.

Security implications for vars()

Certainly, here are some security implications to consider when using vars() in Python.

I. Exposing Internal State

Be cautious when using vars() as it allows you to access an object’s internal state. In certain situations, exposing this information could pose a security risk by revealing sensitive data.

II. Attribute Tampering

Since vars() enables you to modify object attributes, improper usage can lead to unintentional or malicious changes to an object’s state. This could result in unexpected behavior or security vulnerabilities.

III. Unintended Information Leakage

When serializing objects that contain sensitive information using vars(), ensure that you sanitize or filter out any sensitive data to prevent accidental data leakage.

Congratulations on gaining a solid understanding of Python vars() function and its incredible utility! You’ve learned how this built-in function simplifies the access and manipulation of an object’s attributes especially when dealing with custom classes. However, it’s essential to remember that vars() has its limitations and may not work with certain built-in types or inherited attributes.

With your understanding of vars() syntax, parameters, and what it returns, you’re fully prepared to put this knowledge into action in real-world situations. You’ve explored its capabilities, such as inspecting objects, accessing, modifying, and deleting attributes, as well as using it for testing, data validation, and various other scenarios. All of this flexibility and convenience makes vars() a flexible addition to your Python programming toolkit.

As you continue your Python journey, always keep in mind the security implications of using Python vars(). Be cautious about exposing internal state, unintentional attribute tampering, and potential information leakage. By staying mindful of these considerations, you can harness the power of vars() while ensuring the security of your applications.

With this newfound knowledge and a strong foundation in Python, you’re well on your way to becoming a more proficient and confident programmer. Keep exploring, practicing, and applying what you’ve learned, and you’ll continue to grow as a Python developer. Happy coding!

 
Access ItemsDictionariesFunctionsMethodsmodifying itemsremoving itemsstrings

Author: Marium Azhar

Python super() FunctionPython zip() Function

Scroll to Top