在python2.2之前类与类型分开
类：封装（属性+方法）
类型：整型、浮点型、字符型、字符串型
但之后作者对这俩统一了
将int（）、str（）、list（）这些BIF转化成了工厂函数。
int（）与类d的class是一样的，可以把工厂函数看成类，返回实例对象
type(int)
<class 'type'>
class d:
... pass
...
type(d)
<class 'type'>
将类int（）进行实例化
a = int('123')
b = int('456')
a+b
579
以前上面的语句是将字符串类型改为整型
现在则是将类int（）实例化为a，而“123‘’则是传入的参数
语句：a+b，实际上是对象之间的操作
python专门使用魔法方法定义了对象之间的操作
例如：当检测到对象之间用+号操作时，自动调用int（）类中的__add__方法（魔法方法，在需要的时候自动被调用，就像__init__）
下面创建新的类来继承int（）的所有方法，然后通过改写__add__方法来让+号不执行相加操作，反而执行相减操作
class re_int(int):
def __add__(self, other): # 检测到对象间“+”号，自动执行该方法
return int.__sub__(self, other) # 返回值为：int（）类中的相减操作
def __sub__(self, other): # 检测到对象间“-”号，自动执行该方法
return int.__add__(self, other) # 返回值为：int（）类中的相加操作
a = re_int('5')
b = re_int('3')
print(a + b)
2 # 运行结果
如此，我们在类re_int（）中交换了符号“+”与符号“-”的作用，使由类产生的实例化对象a与b在执行符号：“+”与“-”的操作时并不像通常认知的那样。
我们仿佛深入到了更加底层的代码，上帝之手像你召唤唤唤唤唤！！！
下面让我们来康康父类int（）中的魔法方法是如何实现的：
（dir（类名）：查看类中所有方法名和属性名）
（help（类名.方法名）：查看类中方法）
help(int.__add__)
Help on wrapper_descriptor:
__add__(self, value, /)
Return self+value.
help(int.__sub__)
Help on wrapper_descriptor:
__sub__(self, value, /)
Return self-value.
上面我们看到了int（）类中add方法的实现过程
如果将我们的re_int类不继承int而是自己定义add方法能实现实例对象的加法运算吗？
class re_int(int):
def __add__(self, other,/): # 检测到对象间“+”号，自动执行该方法
return self+other # 返回值为：int（）类中的相减操作
def __sub__(self, other,/): # 检测到对象间“-”号，自动执行该方法
return self-other # 返回值为：int（）类中的相加操作
a = re_int('5')
b = re_int('3')
print(a+b)
运行结果发现超出做大递归数
Traceback (most recent call last):
File "D:/FishC/作业/41_48_魔法方法/11.py", line 17, in <module>
print(a+b)
File "D:/FishC/作业/41_48_魔法方法/11.py", line 8, in __add__
return self+other # 返回值为：int（）类中的相减操作
File "D:/FishC/作业/41_48_魔法方法/11.py", line 8, in __add__
return self+other # 返回值为：int（）类中的相减操作
File "D:/FishC/作业/41_48_魔法方法/11.py", line 8, in __add__
return self+other # 返回值为：int（）类中的相减操作
[Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
要想正确运行可以在返回前面加上int()，这样返回的是整型的相加
class re_int(int):
def __add__(self, other,/): # 检测到对象间“+”号，自动执行该方法
return int(self)+int(other) # 返回值为：int（）类中的相减操作
def __sub__(self, other,/): # 检测到对象间“-”号，自动执行该方法
return int(self)-int(other) # 返回值为：int（）类中的相加操作
a = re_int('5')
b = re_int('3')
print(a+b)
例子1：
两个字符串相加会自动拼接字符串，但遗憾的是两个字符串相减却抛出异常。
因此，现在我们要求定义一个 Nstr 类，支持字符串的相减操作：
A – B，从 A 中去除所有 B 的子字符串
class Nstr(str):
def __sub__(self, other):
for each in other:
if each in self:
self = self.replace(each, '')
return str(self)
运行结果：
Nstr类继承str类的所有属性和方法：
检测到减号自动调用__sub__魔法方法
（虽然str类中没有__sub__方法，但是子类Nstr产生的实例遇到“-”号仍然会自动运行__sub__方法）
self是a，other是b
（a与b都是同一个类产生的对象，所以能调用共同的类方法进行操作）
>>> a = Nstr('I love FishC.com!iiiiiiii')
>>> b = Nstr('i')
>>> print(a - b)
I love FshC.com!
例子2：
#定义一个类 Nstr
#当该类的实例对象间发生的加、减、乘、除运算时
#将该对象的所有字符串的 ASCII 码之和进行计算
#查看ASCII: ord(字符)
class Nstr(str):
def __add__(self, other): # 遇到符号：+ 自动运行魔法方法__add__(NB)
s1 = 0
s2 = 0
for each in self:
s1 += int(ord(each))
for each in other:
s2 += int(ord(each))
return s1 + s2
def __sub__(self, other):
s1 = 0
s2 = 0
for each in self:
s1 += int(ord(each))
for each in other:
s2 += int(ord(each))
return s1 - s2
def __mul__(self, other):
s1 = 0
s2 = 0
for each in self:
s1 += int(ord(each))
for each in other:
s2 += int(ord(each))
return s1 * s2
def __truediv__(self, other):
s1 = 0
s2 = 0
for each in self:
s1 += int(ord(each))
for each in other:
s2 += int(ord(each))
return s1 / s2
运行结果：
>>> a = Nstr('FishC')
>>> b = Nstr('love')
print(a+b,a-b,a*b,a/b)
899 23 201918 1.052511415525114