Python语言提供了运算符重载功能，增强了语言的灵活性，这一点与C++有点类似又有些不同。鉴于它的特殊性，今天就来讨论一下Python运算符重载。

      Python语言本身提供了很多魔法方法，它的运算符重载就是通过重写这些Python内置魔法方法实现的。这些魔法方法都是以双下划线开头和结尾的，类似于__X__的形式，python通过这种特殊的命名方式来拦截操作符，以实现重载。当Python的内置操作运用于类对象时，Python会去搜索并调用对象中指定的方法完成操作。



       类可以重载加减运算、打印、函数调用、索引等内置运算，运算符重载使我们的对象的行为与内置对象的一样。Python在调用操作符时会自动调用这样的方法，例如，如果类实现了__add__方法，当类的对象出现在+运算符中时会调用这个方法。



常见运算符重载方法


方法名



重载说明



运算符调用方式



__init__



构造函数



对象创建: X = Class(args)



__del__



析构函数



X对象收回



__add__/__sub__



加减运算



 X+Y， X+=Y/X-Y， X-=Y



__or__



运算符|



X|Y, X|=Y



_repr__／__str__



打印／转换



print(X)、repr(X)／str(X)



__call__



函数调用



X(*args, **kwargs)



__getattr__



属性引用



X.undefined



__setattr__



属性赋值



X.any=value



__delattr__



属性删除



del X.any



__getattribute__



属性获取



X.any



__getitem__



索引运算



X[key]，X[i:j]



__setitem__



索引赋值



X[key]，X[i:j]=sequence



__delitem__



索引和分片删除



del X[key]，del X[i:j]



__len__



长度



len(X)



__bool__



布尔测试



bool(X)



__lt__, __gt__, 

__le__, __ge__, 

__eq__, __ne__



特定的比较



依次为X<Y，X>Y，X<=Y，X>=Y， 

X==Y，X!=Y 

注释：（lt: less than, gt: greater than, 

  le: less equal, ge: greater equal, 

  eq: equal, ne: not equal 

）



__radd__



右侧加法



other+X



__iadd__



实地（增强的）加法



X+=Y(or else __add__)



__iter__, __next__



迭代



I=iter(X), next()



__contains__



成员关系测试



item in X(X为任何可迭代对象)



__index__



整数值



hex(X), bin(X),  oct(X)



__enter__, __exit__



环境管理器



with obj as var:



__get__, __set__, 

__delete__



描述符属性



X.attr, X.attr=value, del X.attr



__new__



创建



在__init__之前创建对象





       下面对常用的运算符方法的使用进行一下介绍。

构造函数和析构函数：__init__和__del__

       它们的主要作用是进行对象的创建和回收，当实例创建时，就会调用__init__构造方法。当实例对象被收回时，析构函数__del__会自动执行。



[python] view
 plain copy





>>> 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__  



加减运算：__add__和__sub__

       重载这两个方法就可以在普通的对象上添加＋－运算符操作。下面的代码演示了如何使用＋－运算符，如果将代码中的__sub__方法去掉，再调用减号运算符就会出错。





[python] view
 plain copy





>>> 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  

对象的字符串表达形式：__repr__和__str__



       这两个方法都是用来表示对象的字符串表达形式：print()、str()方法会调用到__str__方法，print()、str()和repr()方法会调用__repr__方法。从下面的例子可以看出，当两个方法同时定义时，Python会优先搜索并调用__str__方法。





[python] view
 plain copy





>>> 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'  



索引取值和赋值：__getitem__, __setitem__

       通过实现这两个方法，可以通过诸如 X[i] 的形式对对象进行取值和赋值，还可以对对象使用切片操作。





[python] view
 plain copy





>>> 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]  



设置和访问属性：__getattr__、__setattr__

       我们可以通过重载__getattr__和__setattr__来拦截对对象成员的访问。__getattr__在访问对象中不存在的成员时会自动调用。__setattr__方法用于在初始化对象成员的时候调用，即在设置__dict__的item时就会调用__setattr__方法。具体例子如下：



[python] view
 plain copy





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()  

       上面代码的运行结果如下，从结果可以看出，访问不存在的变量x时会调用__getattr__方法；当__init__被调用的时候，赋值运算也会调用__setattr__方法。






[python] view
 plain copy





__setattr__  

__setattr__  

{'a': 1, 'b': 2}  

__getattr__  

__setattr__  

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

迭代器对象: __iter__,  __next__



       Python中的迭代，可以直接通过重载__getitem__方法来实现，看下面的例子。






[python] view
 plain copy





>>> 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  
       通过上面的方法是可以实现迭代，但并不是最好的方式。Python的迭代操作会优先尝试调用__iter__方法，再尝试__getitem__。迭代环境是通过iter去尝试寻找__iter__方法来实现，而这种方法返回一个迭代器对象。如果这个方法已经提供，Python会重复调用迭代器对象的next()方法，直到发生StopIteration异常。如果没有找到__iter__，Python才会尝试使用__getitem__机制。下面看一下迭代器的例子。



[python] view
 plain copy





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  
       程序的运行结果如下：







[python] view
 plain copy





__next__ called  

4  

__next__ called  

5  

__next__ called  

6  

__next__ called  

-----------  

__next__ called  

4  

__next__ called  

5  

__next__ called  

6  

__next__ called  
       可见实现了__iter__和__next__方法后，可以通过for in的方式迭代遍历对象，也可以通过iter()和next()方法迭代遍历对象。

三元运算符 python
Python ternary operator is also termed as conditional operator. This is because it can evaluate a statement with a condition being true or false.
 Python三元运算符也称为条件运算符。 这是因为它可以评估条件为true或false的语句。 
 Python三元运算符 (Python ternary operator)
Python ternary operator was introduced in Python 2.5.
 Python 2.5中引入了Python三元运算符。 
If used properly, ternary operator can reduce code size and increase readability of the code.
 如果使用正确，三元运算符可以减小代码大小并提高代码的可读性。 
There is no special keyword for ternary operator, it’s the way of writing if-else statement that creates a ternary statement or conditional expression.
 三元运算符没有特殊的关键字，这是编写if-else语句的方法，该语句创建三元语句或条件表达式。 
 Python三元运算符语法 (Python ternary operator syntax)
Python ternary operator is written with simple syntax using if else statement.
 Python三元运算符使用if else语句以简单的语法编写。 

[when_true] if [condition] else [when_false]
 Python三元运算符示例 (Python ternary operator example)
On the above syntax, let us quickly build up an example:
 基于以上语法，让我们快速构建一个示例： 
is_fast = True
car = "Ferrari" if is_fast else "Sedan"
Clearly, the presented example is a lot more readable than the usual if statement, as follows:
 显然，所提供的示例比通常的if语句更具可读性，如下所示： 
if is_fast:
    car = "Ferrari"
else:
    car = "Sedan"
Of course, python ternary operator made above code very small.
 当然，python三元运算符使上面的代码非常小。 
A very easy way to remember the order of condition is just like you think it, for example, based on above code snippet, we say “Car is Ferrari if it is fast otherwise it is Sedan”, sounds easy now, right?
 记住条件顺序的一种非常简单的方法就像您认为的那样，例如，根据上述代码片段，我们说“汽车是法拉利，如果速度很快，否则它是轿车”，现在听起来很容易，对吧？ 
 具有Tuple的Python三元运算符示例 (Python ternary operator example with Tuple)
The operation shown in the earlier section was a simple replacement for if-else conditions. Well, Ternary operators are much more powerful than those.
 前面部分中显示的操作是if-else条件的简单替代。 好吧，三元运算符的功能要强大得多。 
We can use ternary operator with tuple too.
 我们也可以将三元运算符与元组一起使用。 
(when_false, when_true)[condition]
Please note that in this syntax, False value is before True value. Consider this more complex example which works with Tuples:
 请注意，在此语法中， False值在True值之前 。 考虑下面这个更适合Tuples的例子： 
is_fast = True
car = ("Sedan", "Ferrari")[is_fast]
This is a very less used syntax as it might not represent clear readability like before. Also, it’s important to consider the performance of this method as this will result in both elements of the Tuple being evaluated. The earlier ternary operator didn’t result in this lag. Below image shows the output of ternary operator example code.
 这是一种很少使用的语法，因为它可能不像以前那样代表清晰的可读性。 同样，考虑此方法的性能也很重要，因为这将导致对元组的两个元素进行评估。 较早的三元运算符没有导致这种滞后。 下图显示了三元运算符示例代码的输出。 
 Python三元运算符的优势 (Python ternary operator advantages)
Main advantages offered by ternary operator are:
 三元运算符提供的主要优点是： 
It allows us to replace simple if statements with a single line expression.
 它允许我们用单行表达式替换简单的if语句。 
Increases code readability by reducing number of lines of code.
 通过减少代码行数来提高代码的可读性。 
In this quick lesson, we studied the ternary operators in Python which were introduced in Python 2.5. Use them to shorten your code and make it more maintainable and easily readable.
 在本快速课程中，我们研究了Python 2.5中引入的Python三元运算符。 使用它们可以缩短您的代码，使其更易于维护和阅读。 
翻译自: https://www.journaldev.com/17225/python-ternary-operator
三元运算符 python

类型转换是一种让程序员能够暂时或永久性改变编译器对对象的解释机制。可改变对象解释方式的运算符称为类型转换运算符。
为何需要进行类型转换
通常为了实现使用不同环境的个人和厂商编写的模块能够相互调用和协作，程序员需要让编译器按照所需的方式解释数据，并成功编译和执行。一个非常经典的例子是：目前很多C++程序依然在使用很多年前用C编写的库，而针对这些C语言编译器编写的库必须依赖整形来保存布尔值，因此对于这些编译器来说，bool类型的定义就类似于：
typedef unsigned short BOOL，返回布尔值的函数可能这样声明：BOOL IsX()
而C++编译器支持bool，单位false和true。如果在新的C++应用程序中使用这样的库，程序员必须让其使用的C++编译器能够理解数据类型bool，同时让库能够理解数据类型bool，因此，可使用类型转换：bool bCPPResult = (bool) IsX();很明显这是C风格类型转换。而纯粹的C++语法论者认为这样的转换不伦不类，推崇纯粹的C++风格类型转换。
C++ 类型转换运算符
static_cast，dynamic_cast，reinterpret_cast，const_cast
完全相同的语法：destination_type result = cast_type <destination_type>(object_to_be_casted)
static_cast : 
静态类型转换，实现编译阶段检查，确保指针转换为相关类型，可用于相关类型的指针之间进行转换，还可显式地执行标准数据类型的类型转换。在C语言中可将一个对象的指针转换为完全不相关的类型，而编译器不会报错。而是用static_cast则会对指针相关性进行检查，如果不相关，则编译器会报错。同时static_cast可以实现指针向上转换为基类类型，向下转换为派生类型，但不会在运行阶段执行检查。而通常向下转换为派生类型时，在运行阶段会有可能导致意外结果。因此便有了下面的动态类型转换。
 
dynamic_cast：
动态类型转换，在运行阶段执行类型转换，可检查操作结果，如果为NULL则转换失败。所以采用动态类型转换，一定要进行指针的判断。这种在运行阶段识别对象类型的机制称为运行阶段类型识别（RTTI，runtime type identification）
 
reinterpret_cast:
属于强制类型转换，与C风格类型转换最接近。不进行相关性判断，强制编译器接收static_cast通常不允许的类型转换，一般用于低级的驱动程序。一般不使用这种方式。
 
const_cast：
让程序员能够关闭对象的访问修饰符const。通常修改由于使用const引用来调用non-const成员函数编译导致的错误，利用const_cast把const引用转变为non-const引用，然后就可以顺利的编译和执行。
 
C++ 类型转换运算符存在的问题
在现代C++中，除了dynamic_cast之外的类型转换都是可以避免的，仅当需要满足遗留应用程序需求时，才需要使用其他类型转换运算符。重要的是，一旦使用类型转换，务必要知道幕后发生的情况。
在使用中应牢记：将派生类转换为基类类型叫做向上转换，是安全的；将基类类型转换为派生类类型叫做向下转换，除非使用dynamic_cast否者是不安全的；请牢记，创建继承层次结构时，应尽量将函数声明为虚函数，这样通过基类指针调用这些函数时，如果该指针指向的是派生类对象，将调用相应类的函数版本；在使用dynamic_cast别忘了对指针进行检查，看其是否有效。
 
 
 
 
 

由于前缀自增与后缀自增在如果通过运算符重载在形式上相同，都为
以Date类为例 Date& operator++(Date &)（全局函数）/ Date& operator++( )（成员函数）无法区分。
故人为规定前缀自增与后缀自增运算符的表达形式：
由于编译器必须能够识别出前缀自增与后缀自增，故人为规定了用一个 int 区分，并没有实际的含义。


前缀自增示例 
Calendar& Calendar::operator++(){
	tick();
	return *this;
}




后缀自增示例

Calendar Calendar::operator++(int){
	
	Calendar temp = *this;
	tick();
	return temp;
	

	/*
	tick();
	return *this;
	*/

}


上面会出现3次析构，Temp会导致一次析构。

下面只有两次析构，并没有保存传进来的副本








头文件
#ifndef CALENDAR
#define CALENDAR
#include <iostream>
#include <cstdio>
#include <iomanip>
#include <windows.h>
using namespace std;

class Calendar;

ostream &operator<<(ostream & output, Calendar &C);


class Calendar{
	friend ostream &operator<<(ostream & output, Calendar &C);

public:
	Calendar(int y = 2015, int m = 8, int d = 6, int h = 17, int mm = 9, int s = 0)
		:year(y), month(m), day(d), hour(h), minute(mm), second(s){
	}
	//operator 

	Calendar &operator++();
	Calendar operator++(int);

	void tick(){
		++second;
	}

	~Calendar(){
		cout << "Destructor" << endl;
	}

private:
	int day;
	int month;
	int year;
	int hour;
	int minute;
	int second;
	FILE *fp;
};

Calendar& Calendar::operator++(){
	tick();
	return *this;
}

Calendar Calendar::operator++(int){
	
	Calendar temp = *this;
	tick();
	return temp;
	

	/*
	tick();
	return *this;
	*/

}

ostream &operator<<(ostream & output, Calendar &C){
	output << ""
		<< setw(15) << "Year: " << C.year << " "
		<< setw(15) << "Month: " << C.month << " "
		<< setw(15) << "Day: " << C.day << " " << endl
		<< setw(15) << "Hour: " << C.hour << " "
		<< setw(15) << "Minute: " << C.minute << " "
		<< setw(15) << "Second: " << C.second << " " << endl;

	return output;
}

#endif







主函数
int main(){
	Calendar a;

	cout << a << endl;

	cout << ++a << endl;

	cout << a++ << endl;
	cout << a << endl;


	return 0;
}