Home > Article > Backend Development > 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
##Method name | Overloading description | Operator calling method |
Constructor | Object creation: X = Class(args)||
Destructor | X object is recovered||
Addition and subtraction operations | X+Y, X+=Y/X-Y, X-=Y | |
Operator| | X|Y, X|= Y | |
Print/Convert | print (X)、repr(X)/str(X) | |
Function call | X(*args, **kwargs) | |
Attribute | X.undefined | |
Attribute assignment | X.any=value | |
Attribute | Deletedel X.any | ##getattribute |
Attribute get |
X.any |
getitem |
Index operation |
X[ key | ],X[i:j]setitem |
Index assignment |
X[key],X[ i:j]=sequence |
delitem |
Index and shard deletion |
del X[key],del X[i:j] |
len |
length |
len(X) |
bool |
Boolean test |
bool(X) |
lt, gt, |
eq, ne Specific comparison |
The order is Xe517dc76a8c44253f5d26626e78fb3c6Y,Xc5d9b058e60cc3167c37a93583d2b500= Y, | X==Y,X!=Y
Note :(lt: less than, gt: greater than, less equal, ge: greater equal, ##radd |
other+X | ##iadd | Field (enhanced) addition |
X+=Y(or else | add)iter, next |
|
contains | Membership test | |
item in X (X is any iterable object) |
##index | ##Integer | Value
hex(X), bin(X), oct(X) |
Environment Manager |
|
get, set, | delete||
X.attr, X.attr=value, del X.attr | ||
create |
before init Create Object |
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
variablex; 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
Traverse the objectYou can also iterate through the object through the iter() and next() methods. 【Related Recommendations】
1.
Special Recommendation: "php Programmer Toolbox" V0.1 version download2.
Python Free Video TutorialPython Basics Introduction TutorialThe 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!