Python has numerous collections of dunder methods(which start with double underscores and end with double underscores) to perform various tasks. The most commonly used dunder method is __init__ which is used in Python classes to create and initialize objects.
In this article, we’ll see the usage and implementation of the underutilized dunder methods such as __getitem__, __setitem__, and __delitem__ in Python.
__getitem__
The name __getitem__ depicts that this method is used to access the items from the list, dictionary, and array.
If we have a list of names and want to access the item on the third index, we will use name_list[3], which will return the name from the list on the third index. When the name_list[3] is evaluated, Python internally calls __getitem__ on the data (name_list.__getitem__(3)).
The following example shows us the practical demonstration of the above theory.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
# List of names my_list = ['Sachin', 'Rishu', 'Yashwant', 'Abhishek'] # Accessing items using bracket notation print('Accessed items using the bracket notation') print(my_list[0]) print(my_list[2], "\n") # Accessing items using __getitem__ print('Accessed items using the __getitem__') print(my_list.__getitem__(1)) print(my_list.__getitem__(3)) |
We used the commonly used bracket notation to access the items from the my_list at the 0th and 2nd index and then to access the items at the 1st and 3rd index, we implemented the __getitem__ method.
|
1 2 3 4 5 6 7 |
Accessed items using the bracket notation Sachin Yashwant Accessed items using the __getitem__ Rishu Abhishek |
Syntax
__getitem__(self, key)
The __getitem__ is used to evaluate the value of self[key] by the object or instance of the class. Just like we saw earlier, object[key] is equivalent to object.__getitem__(key).
self – object or instance of the class
key – value we want to access
__getitem__ in Python classes
|
1 2 3 4 5 6 7 8 9 10 |
# Creating a class class Products: def __getitem__(self, items): print(f'Item: {items}') item = Products() item['RAM', 'ROM'] item[{'Storage': 'SSD'}] item['Graphic Card'] |
We created a Python class named Products and then defined the __getitem__ method to print the items. Then we created an instance of the class called item and then passed the values.
|
1 2 3 |
Item: ('RAM', 'ROM') Item: {'Storage': 'SSD'} Item: Graphic Card |
These values are of various data types and were actually parsed, for example, item['RAM', 'ROM'] was parsed as a tuple and this expression was evaluated by the interpreter as item.__getitem__(('RAM', 'ROM')).
Checking the type of the item along with the items.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import math # Creating a class class Products: # Printing the types of item along with items def __getitem__(self, items): print(f'Item: {items}. Type: {type(items)}') item = Products() item['RAM', 'ROM'] item[{'Storage': 'SSD'}] item['Graphic Card'] item[math] item[89] |
Output
|
1 2 3 4 5 |
Item: ('RAM', 'ROM'). Type: <class 'tuple'> Item: {'Storage': 'SSD'}. Type: <class 'dict'> Item: Graphic Card. Type: <class 'str'> Item: <module 'math' (built-in)>. Type: <class 'module'> Item: 89. Type: <class 'int'> |
Example
In the following example, we created a class called Products, an __init__ that takes items and a price, and a __getitem__ that prints the value and type of the value passed inside the indexer.
Then we instantiated the class Products and passed the arguments 'Pen' and 10 to it, which we saved inside the obj. Then, using the instance obj, we attempted to obtain the values by accessing the parameters items and price.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
# Creating a class class Products: # Creating a __init__ function def __init__(self, items, price): self.items = items self.price = price def __getitem__(self, value): print(value, type(value)) # Creating instance of the class and passing the values obj = Products('Pen',10) # Accessing the values obj[obj.items] obj[obj.price] |
Output
|
1 2 |
Pen <class 'str'> 10 <class 'int'> |
__setitem__
The __setitem__ is used to assign the values to the item. When we assign or set a value to an item in a list, array, or dictionary, this method is called internally.
Here’s an example in which we created a list of names, and attempted to modify the list by changing the name at the first index (my list[1] = 'Yogesh'), and then printed the updated list.
To demonstrate what the interpreter does internally, we modified the list with the help of __setitem__.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
# List of names my_list = ['Sachin', 'Rishu', 'Yashwant', 'Abhishek'] # Assigning other name at the index value 1 my_list[1] = 'Yogesh' print(my_list) print('-'*20) # What interpreter does internally my_list.__setitem__(2, 'Rishu') print(my_list) |
When we run the above code, we’ll get the following output.
|
1 2 3 |
['Sachin', 'Yogesh', 'Yashwant', 'Abhishek'] -------------------- ['Sachin', 'Yogesh', 'Rishu', 'Abhishek'] |
Syntax
__setitem__(self, key, value)
The __setitem__ assigns a value to the key. If we call self[key] = value, then it will be evaluated as self.__setitem__(key, value).
self – object or instance of the class
key – the item that will be replaced
value – key will be replaced by this value
__setitem__ in Python classes
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
# Creating a class class Roles: # Defining __init__ method def __init__(self, role, name): # Creating a dictionary with key-value pair self.detail = { 'name': name, 'role': role } # Defining __getitem__ method def __getitem__(self, key): return self.detail[key] # Function to get the role and name def getrole(self): return self.__getitem__('role'), self.__getitem__('name') # Defining __setitem__ method def __setitem__(self, key, value): self.detail[key] = value # Function to set the role and name def setrole(self, role, name): print(f'{role} role has been assigned to {name}.') return self.__setitem__('role', role), self.__setitem__('name', name) # Instantiating the class with required args data = Roles('Python dev', 'Sachin') # Printing the role with name print(data.getrole()) # Setting the role for other guys data.setrole('C++ dev', 'Rishu') # Printing the assigned role with name print(data.getrole()) # Setting the role for other guys data.setrole('PHP dev', 'Yashwant') # Printing the assigned role with name print(data.getrole()) |
The following example demonstrates the implementation of the __setitem__ method in a Python class.
We created a Roles class and a __init__ function, passing the role and name parameters and storing them in a dictionary.
Then we defined the __getitem__ method, which returns the key’s value, and the getrole() function, which accesses the value passed to the key name and role.
Similarly, we defined the __setitem__ method, which assigns a value to the key, and we created the setrole() function, which assigns the specified values to the key role and name.
The class Roles('Python dev,' 'Sachin') was then instantiated with required arguments and stored inside the data object. We printed the getrole() function to get the role and name, then we called the setrole() function twice, passing it the various roles and names, and printing the getrole() function for each setrole() function we defined.
|
1 2 3 4 5 |
('Python dev', 'Sachin') C++ dev role has been assigned to Rishu. ('C++ dev', 'Rishu') PHP dev role has been assigned to Yashwant. ('PHP dev', 'Yashwant') |
We got the values passed as an argument to the class but after it, we set the different roles and names and got the output we expected.
__delitem__
The __delitem__ method deletes the items in the list, dictionary, or array. The item can also be deleted using the del keyword.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
# List of names my_list = ['Sachin', 'Rishu', 'Yashwant', 'Abhishek'] # Deleting the first item of the list del my_list[0] print(my_list) # Deleting the item using __delitem__ my_list.__delitem__(1) print(my_list) ---------- ['Rishu', 'Yashwant', 'Abhishek'] ['Rishu', 'Abhishek'] |
In the above code, we specified the del keyword and then specified the index number of the item to be deleted from my_list.
So, when we call del my_list[0] which is equivalent to del self[key], Python will call my_list.__delitem__(0) which is equivalent to self.__delitem__(key).
__delitem__ in Python class
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
class Friends: def __init__(self, name1, name2, name3, name4): self.n = { 'name1': name1, 'name2': name2, 'name3': name3, 'name4': name4 } # Function for deleting the entry def delname(self, key): self.n.__delitem__(key) # Function for adding/modifying the entry def setname(self, key, value): self.n[key] = value friend = Friends('Sachin', 'Rishu', 'Yashwant', 'Abhishek') print(friend.n, "\n") # Deleting an entry friend.delname('name3') print('After deleting the name3 entry') print(friend.n, "\n") # Modifying an entry friend.setname('name2', 'Yogesh') print('name2 entry modified') print(friend.n, "\n") # Deleting an entry friend.delname('name2') print('After deleting the name2 entry') print(friend.n) |
We defined the delname function in the preceding code, which takes a key and deletes that entry from the dictionary created inside the __init__ function, as well as the setname function, which modifies/adds the entry to the dictionary.
Then we instantiated the Friends class, passed in the necessary arguments, and stored them in an instance called friends.
Then we used the delname function to remove an entry with the key name3 before printing the updated dictionary. In the following block, we modified the entry with the key name2 to demonstrate the functionality of setname function and printed the modified dictionary, then we deleted the entry with the key name2 and printed the updated dictionary.
|
1 2 3 4 5 6 7 8 9 10 |
{'name1': 'Sachin', 'name2': 'Rishu', 'name3': 'Yashwant', 'name4': 'Abhishek'} After deleting the name3 entry {'name1': 'Sachin', 'name2': 'Rishu', 'name4': 'Abhishek'} name2 entry modified {'name1': 'Sachin', 'name2': 'Yogesh', 'name4': 'Abhishek'} After deleting the name2 entry {'name1': 'Sachin', 'name4': 'Abhishek'} |
Conclusion
We learned about the __getitem__, __setitem__, and __delitem__ methods in this article. We can compare __getitem__ to a getter function because it retrieves the value of the attribute, __setitem__ to a setter function because it sets the value of the attribute, and __delitem__ to a deleter function because it deletes the item.
We implemented these methods within Python classes in order to better understand how they work.
We’ve seen code examples that show what Python does internally when we access, set, and delete values.
🏆Other articles you might be interested in if you liked this one
✅How to use and implement the __init__ and __call__ in Python.
✅Types of class inheritance in Python with examples.
✅How underscores modify accessing the attributes and methods in Python.
✅Create and manipulate the temporary file in Python.
✅Display the static and dynamic images on the frontend using FastAPI.
✅Python one-liners to boost your code.
✅Perform a parallel iteration over multiple iterables using zip() function in Python.
That’s all for now
Keep Coding✌✌
