最新的 Python3.7 中(2018.07.13)，对类的构造函数进行了精简。

3.7 版本：

from dataclasses import dataclass
@dataclass
class A:
  x:int
  y:int
  def add(self):
    return self.x + self.y

相当于以前的：

class A:
  def __init__(self,x,y):
    self.x = x
    self.y = y
  def add(self):
    return self.x + self.y

反向运算符重载：

• __radd__: 加运算
• __rsub__: 减运算
• __rmul__: 乘运算
• __rdiv__: 除运算
• __rmod__: 求余运算
• __rpow__: 乘方

复合重载运算符：

• __iadd__: 加运算
• __isub__: 减运算
• __imul__: 乘运算
• __idiv__: 除运算
• __imod__: 求余运算
• __ipow__: 乘方

运算符重载的时候：

#!/usr/bin/python3

class Vector:
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def __str__(self):
        return 'Vector (%d, %d)' % (self.a, self.b)

    def __repr__(self):
        return 'Vector (%d, %d)' % (self.a, self.b)

    def __add__(self,other):
        if other.__class__ is Vector:
            return Vector(self.a + other.a, self.b + other.b)
        elif other.__class__ is int:
            return Vector(self.a+other,self.b)

    def __radd__(self,other):
        """反向算术运算符的重载
        __add__运算符重载可以保证V+int的情况下不会报错，但是反过来int+V就会报错，通过反向运算符重载可以解决此问题
        """

        if other.__class__ is int or other.__class__ is float:
            return Vector(self.a+other,self.b)
        else:
            raise ValueError("值错误")

    def __iadd__(self,other):
        """复合赋值算数运算符的重载
        主要用于列表，例如L1+=L2,默认情况下调用__add__，会生成一个新的列表，
        当数据过大的时候会影响效率，而此函数可以重载+=，使L2直接增加到L1后面
        """

        if other.__class__ is Vector:
            return Vector(self.a + other.a, self.b + other.b)
        elif other.__class__ is int:
            return Vector(self.a+other,self.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)
print (v1+5)
print (6+v2)

关于 __name__

首先需要了解 __name__ 是属于 python 中的内置类属性，就是它会天生就存在于一个 python 程序中，代表对应程序名称。

比如所示的一段代码里面（这个脚本命名为 pcRequests.py），我只设了一个函数，但是并没有地方运行它，所以当 run 了这一段代码之后我们有会发现这个函数并没有被调用。但是当我们在运行这个代码时这个代码的 __name__ 的值为 __main__ （一段程序作为主线运行程序时其内置名称就是 __main__）。

import requests
class requests(object):
    def __init__(self,url):
        self.url=url
        self.result=self.getHTMLText(self.url)
    def getHTMLText(url):
        try:
            r=requests.get(url,timeout=30)
            r.raise_for_status()
            r.encoding=r.apparent_encoding
            return r.text
        except:
            return "This is a error."
print(__name__)

结果：

__main__
Process finished with exit code 0

当这个 pcRequests.py 作为模块被调用时，则它的 __name__ 就是它自己的名字：

import pcRequestspcRequestsc=pcRequestsc.__name__

结果：

'pcRequests'

看到这里应该能明白，自己的 __name__ 在自己用时就是 main，当自己作为模块被调用时就是自己的名字，就相当于：我管自己叫我自己，但是在朋友眼里我就是小仙女一样。

所有专有方法中，__init__()要求无返回值，或者返回 None。而其他方法，如__str__()、__add__()等，一般都是要返回值的，如下所示：

>>> class Complex:
...     def __init__(self, realpart, imagpart):
...         self.r = realpart
...         self.i = imagpart
...         return 'hello'
...
>>> x = Complex(3.0, -4.5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: __init__() should return None, not 'str'

而对于 __str__()、__add__() 等。

def __str__(self):
        return 'Vector (%d, %d)' % (self.a, self.b)

def __repr__(self):
    return 'Vector (%d, %d)' % (self.a, self.b)

def __add__(self,other):
    if other.__class__ is Vector:
        return Vector(self.a + other.a, self.b + other.b)
    elif other.__class__ is int:
        return Vector(self.a+other,self.b)

笔记中有位同学如下这样写道，但我认为不准确：

最新的 Python3.7 中(2018.07.13)，对类的构造函数进行了精简。

3.7 版本：

from dataclasses import dataclass
@dataclass
class A:
  x:int
  y:int
  def add(self):
    return self.x + self.y

相当于以前的：

class B:
  def __init__(self,x,y):
    self.x = x
    self.y = y
  def add(self):
    return self.x + self.y

实际上，对于类 A， 实例化时不需要参数；而对于类 B，实例化时需要输入 (x, y) 参数，这才是两者的核心区别。定义类时，若需要输入参数，则一般必须使用 __init__()方法；若不需要输入参数，是否使用 __init__() 方法都可以。

和版本是否对类的构造函数进行了精简，关系不大。

类的二元方法运算符重载介绍的并不全面，文中介绍的全是正向方法，其实还有反向方法，就地方法。下面补充一些。

当解释器碰到 a+b 时，会做以下事情：

从 a 类中找 __add__ 若返回值不是 NotImplemented, 则调用 a.__add__(b)。

若 a 类中没有 __add__ 方法，则检查 b 有没有 __radd__ 。如果如果有，则调用 b.__radd__(a)，若没有，则返回 NotImplemented。

接上条，若 b 也没有 __radd__ 方法，则抛出 TypeError，在错误消息中知名操作数类型不支持。

比如：向量类 <Myvector> 应当有向量与整数的乘法:

>>>a = Myvector([1,2,3])
>>>print(a.value)
[1,2,3]
>>>b=3
>>>c = a*b   #此时调用Myvector.__mul__()
>>>print(c.value)
[3,6,9]
>>> d=b*a  #这句会出错。

期望得到 b*a 也返回一个向量，b*a 应该等于 a*b。此时就需要在 Myvector 类中定义一个__rmul__方法。

def __rmul__(self, other):
    if isinstance(other, int):
        return Myvector([a*other for a in self.m])

每个运算符都有正向方法重载，反向方法重载。有一些有就地方法（即不返回新的对象，而是修改原本对象）。

在类的方法中直接修改 self 是无效操作，即使 self 变量的地址与实例地址相同：

class C:
  def __init__(self, a):
    self.a = a
  def construct(self, a):
    c = C(a)
    self = c
  def getid(self):
    return id(self)

if __name__ == '__main__':
  c1 = C(2)
  c1.construct(3) # c1.a == 2
  print(id(c1) == c1.getid()) # True

上面给的 people 类定义混淆了类属性与实例属性，下面我给出自己改写的 People 定义予以证明:

# 类定义
class People:    
    name = 'nnnnnn'  #这个是类属性    
    age = 20         #这个也是类属性    
    __weight = 21    #这个也是类属性，且是私有的    
    # 定义构造方法    
    def __init__(self, name, age, weight):        
        self.name = name    #这里改写的是实例属性，与类属性没有关联        
        self.age = age     #这里改写的是实例属性，与类属性没有关联        
        self.__weight = weight  #实例属性, 这里改写的是实例属性，与类属性没有关联        
        #People.__weight = weight    
    def speak(self):        
        print("说: 我叫 {0}，{1} 岁，体重{2}斤（实例属性）" .format(self.name, self.age, self.__weight))    
    def speak2(self):        
        print("私有类属性__weight = {0}".format(People.__weight))

p1 = People('张三', 10, 60)
p1.speak()
p1.speak2()
print("类属性：name={0}, age={1}".format(People.name, People.age))

p2 = People('李四', 12, 69)
p2.speak()
p2.speak2()
print("类属性：name={0}, age={1}".format(People.name, People.age))

运行结果：

说: 我叫 张三，10 岁，体重60斤（实例属性）
私有类属性__weight = 21
类属性：name=nnnnnn, age=20
说: 我叫 李四，12 岁，体重69斤（实例属性）
私有类属性__weight = 21
类属性：name=nnnnnn, age=20