#10 Dunder Methods|Magic Methods|Special methods in python|python for beginners|OOP
#python dunder methods#python#dunder methods#dunder methods in python#python magic methods#python class dunder methods#python dunder methods tutorial#python dunder#python special methods#magic methods in python#magic methods python#python tutorial#dunder methods python list#dunder magic methods python#magic methods#python class methods#dunder methods in python list#dunder methods in python in telugu#magic dunder method in python#python classes#python in telugu#dunder methods in python#python#dunder methods in python in telugu#python dunder methods#learn python in telugu#oops in telugu#dunder method in python#object orientated programming in telugu#object oriented programming in python#python tutorial in telugu#python language in telugu#oops in python#magic methods in python#python oops in telugu#python for beginners in telugu#python telugu#__del__ in python#__init__ in python
--------------------------------------------------------------------------------------------------------
operator overloading -- • #6 Operator Overloading in python||polymor...
--------------------------------------------------------------------------------------
Dunder methods, short for "double underscore" methods, are special methods in Python that have double underscores at the beginning and end of their names (e.g., `__init__`, `__str__`). They are also known as "magic methods" because they enable the customization of class behavior and interact with Python's built-in functions and operators.
Key Points About Dunder Methods
1. **Special Naming**: Dunder methods are recognizable by their double underscores at both ends of their names.
2. **Built-in Interaction**: They allow objects to interact with Python's built-in functions and operators.
3. **Customization**: They enable the customization of how objects are created, represented, and manipulated.
Common Dunder Methods and Examples
1. **`__init__`**: Constructor method, called when an instance of a class is created.
```python
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
person = Person("Alice", 30)
print(person.name) # Outputs: Alice
```
2. **`__str__`**: Called by the `str()` function and the `print` statement to provide a human-readable string representation of an object.
```python
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return f"Person(name={self.name}, age={self.age})"
person = Person("Alice", 30)
print(person) # Outputs: Person(name=Alice, age=30)
```
3. **`__repr__`**: Called by the `repr()` function to provide an unambiguous string representation of an object, often used for debugging.
```python
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def __repr__(self):
return f"Person(name={self.name}, age={self.age})"
person = Person("Alice", 30)
print(repr(person)) # Outputs: Person(name=Alice, age=30)
```
4. **`__len__`**: Called by the `len()` function to return the length of an object.
```python
class MyList:
def __init__(self, items):
self.items = items
def __len__(self):
return len(self.items)
my_list = MyList([1, 2, 3, 4])
print(len(my_list)) # Outputs: 4
```
5. **`__getitem__`, `__setitem__`, `__delitem__`**: Enable indexing, assignment, and deletion of items using square bracket notation.
```python
class MyList:
def __init__(self, items):
self.items = items
def __getitem__(self, index):
return self.items[index]
def __setitem__(self, index, value):
self.items[index] = value
def __delitem__(self, index):
del self.items[index]
my_list = MyList([1, 2, 3])
print(my_list[1]) # Outputs: 2
my_list[1] = 10
print(my_list[1]) # Outputs: 10
del my_list[1]
print(my_list.items) # Outputs: [1, 10]
```
6. **`__add__`**: Called by the `+` operator to add two objects.
```python
class Vector:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Vector(self.x + other.x, self.y + other.y)
def __repr__(self):
return f"Vector({self.x}, {self.y})"
v1 = Vector(2, 3)
v2 = Vector(3, 4)
v3 = v1 + v2
print(v3) # Outputs: Vector(5, 7)
```
Summary
Dunder methods are special methods in Python that allow developers to define how objects of a class behave with built-in functions and operators. By implementing these methods, you can customize object creation, representation, arithmetic operations, and more, making your classes more integrated with Python's features and easier to use.