Code tutorial for Python operator overloading

This article mainly introduces the detailed explanation of Python operator overloading and related information of example code. Friends who need it can refer to

Python operator overloading

Provided by Python language It has the operator overloading function and enhances the flexibility of the language. This is somewhat similar to but somewhat different from C++. In view of its special nature, today we will discuss Python operator overloading.

The Python language itself provides many magic methods, and its operator overloading is achieved by rewriting these Python built-in magic methods. These magic methods all start and end with double underscores, similar to the form of X. Python uses this special naming method to intercept the operator to achieve overloading. When Python's built-in operations are applied to class objects , Python will search and call the specified method in the object to complete the operation.

Classes can overload built-in operations such as addition and subtraction, printing, function calls, index, etc. Operator overloading makes the behavior of our objects Same as built-in objects. Python will automatically call such a method when calling an operator. For example, if a class implements the add method, this method will be called when an object of the class appears in the + operator.

Common operator overloading methods

The following is an introduction to the use of commonly used operator methods.

Constructor and destructor: init and del

Their main function is to create and recycle objects. When an instance is created , the initConstructor Method will be called. When the instance object is reclaimed, the destructor del will be executed automatically.

>>> class Human(): 
...   def init(self, n): 
...     self.name = n 
...       print("init ",self.name) 
...   def del(self): 
...     print("del") 
...  
>>> h = Human('Tim') 
init Tim 
>>> h = 'a' 
del

Addition and subtraction operations: add and sub

Overloading these two methods can add +- operator operations to ordinary objects. The following code demonstrates how to use the +- operator. If you remove the sub method in the code and then call the minus operator, an error will occur.

>>> class Computation(): 
...   def init(self,value): 
...     self.value = value 
...   def add(self,other): 
...     return self.value + other 
...   def sub(self,other): 
...     return self.value - other 
...  
>>> c = Computation(5) 
>>> c + 5 
10 
>>> c - 3 
2

String of the objectExpression form: repr and str

>>> class Str(object): 
...   def str(self): 
...     return "str called"   
...   def repr(self): 
...     return "repr called" 
...  
>>> s = Str() 
>>> print(s) 
str called 
>>> repr(s) 
'repr called' 
>>> str(s) 
'str called'

Index value acquisition and assignment: getitem, setitem
## By implementing these two methods, objects can be processed in the form such as X[i] Get and assign values, and you can also use slicing operations on objects.

>>> class Indexer: 
  data = [1,2,3,4,5,6] 
  def getitem(self,index): 
    return self.data[index] 
  def setitem(self,k,v): 
    self.data[k] = v 
    print(self.data) 
>>> i = Indexer() 
>>> i[0] 
1 
>>> i[1:4] 
[2, 3, 4] 
>>> i[0]=10 
[10, 2, 3, 4, 5, 6]

Set and access attributes: getattr, setattr

We can intercept access to object members by overloading getattr and setattr. getattr is automatically called when accessing a member that does not exist in the object. The setattr method is used to call when initializing object members, that is, the setattr method will be called when setting the dict item. The specific example is as follows:

class A(): 
  def init(self,ax,bx): 
    self.a = ax 
    self.b = bx 
  def f(self): 
    print (self.dict) 
  def getattr(self,name): 
    print ("getattr") 
  def setattr(self,name,value): 
    print ("setattr") 
    self.dict[name] = value 
 
a = A(1,2) 
a.f() 
a.x 
a.x = 3 
a.f()

The running results of the above code are as follows. From the results, it can be seen that the getattr method will be called when accessing the non-existent

x; when init is called, the value will be assigned The operation also calls the setattr method.

setattr 
setattr 
{'a': 1, 'b': 2} 
getattr 
setattr 
{'a': 1, 'x': 3, 'b': 2}

Iteration in Python can be implemented directly by overloading the getitem method. See the example below.

>>> class Indexer: 
...   data = [1,2,3,4,5,6] 
...   def getitem(self,index): 
...       return self.data[index] 
...  
>>> x = Indexer() 
>>> for item in x: 
...   print(item) 
...  
1 
2 
3 
4 
5 
6

Iteration exception occurs. If iter is not found, Python will try to use the getitem mechanism. Let's look at an example of an iterator.

class Next(object): 
  def init(self, data=1): 
    self.data = data 
  def iter(self): 
    return self 
  def next(self): 
    print("next called") 
    if self.data > 5: 
      raise StopIteration 
    else: 
      self.data += 1 
      return self.data 
for i in Next(3): 
  print(i) 
print("-----------") 
n = Next(3) 
i = iter(n) 
while True: 
  try: 
    print(next(i)) 
  except Exception as e: 
    break

next called 
4 
next called 
5 
next called 
6 
next called 
----------- 
next called 
4 
next called 
5 
next called 
6 
next called

It can be seen that after implementing the iter and next methods, you can iterate through for in

You can also iterate through the object through the iter() and next() methods. 【Related Recommendations】

1.

Special Recommendation: "php Programmer Toolbox" V0.1 version download2.

3.

The above is the detailed content of Code tutorial for Python operator overloading. For more information, please follow other related articles on the PHP Chinese website!