Python入门【object根类、重写 __str__() 方法 、多重继承、MRO方法解析顺序、 super()获得父类定义、多态、特殊方法和运算符重载、特殊属性】(十六)
作者简介：大家好，我是爱敲代码的小王，CSDN博客博主,Python小白
系列专栏：python入门到实战、Python爬虫开发、Python办公自动化、Python数据分析、Python前后端开发
如果文章知识点有错误的地方，请指正！和大家一起学习，一起进步
如果感觉博主的文章还不错的话，请三连支持一下博主哦
博主正在努力完成2023计划中：以梦为马，扬帆起航，2023追梦人
python入门到实战专栏：从入门到实战
Python爬虫开发专栏：从入门到实战
Python办公自动化专栏：从入门到实战
Python数据分析专栏：从入门到实战
Python前后端开发专栏：从入门到实战
目录
object根类
重写 __str__() 方法
多重继承
MRO方法解析顺序
super()获得父类定义
多态
特殊方法和运算符重载
特殊属性
对象的浅拷贝和深拷贝
object根类
object 类是所有类的父类，因此所有的类都有 object 类的属性和方法。 我们显然有必要深入研究一下 object 类的结构。对于我们继续深入学习Python很有好处。
dir() 查看对象属性
为了深入学习对象，先学习内置函数 dir() ，他可以让我们方便的看到指定对象所有的属性 【测试】查看对象所有属性以及和 object 进行比对
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
def say_age(self):
print(self.name,"的年龄是：",self.age)
obj = object()
print(dir(obj))
s2 = Person("王尚",18)
print(dir(s2))运行结果：
['__class__', '__delattr__', '__dir__',
'__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__gt__', '__hash__',
'__init__', '__init_subclass__', '__le__',
'__lt__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__setattr__',
'__sizeof__', '__str__', '__subclasshook__']
['__class__', '__delattr__', '__dict__',
'__dir__', '__doc__', '__eq__', '__format__',
'__ge__', '__getattribute__', '__gt__',
'__hash__', '__init__', '__init_subclass__',
'__le__', '__lt__', '__module__', '__ne__',
'__new__', '__reduce__', '__reduce_ex__',
'__repr__', '__setattr__', '__sizeof__',
'__str__', '__subclasshook__', '__weakref__',
'age', 'name', 'say_age']从上面我们可以发现这样几个要点：
1、 Person 对象增加了六个属性： __dict__、 __module__、 __weakref__、 age 、name、 say_age
2、 object 的所有属性， Person 类作为 object 的子类，显然包含了所有的属性
3 、我们打印 age 、 name 、 say_age ，发现 say_age 虽然是方法，实际上也是属性。只不过，这个属性的类型是 method 而已。
age
name
say_age ⚠️关于object这些属性的详细学习，会后面学习中逐个涉及。 在此，没必要展开。
重写 __str__() 方法
1、object 有一个 __str__() 方法，用于返回一个对于“对象的描述”。内置函数 str(对象) ,调用的就是 __str__()
2、 __str__() 经常用于 print() 方法，帮助我们查看对象的信息。 __str__() 可以重写
class Person:
def __init__(self,name,age):
self.name = name
self.__age = age
def __str__(self):
'''将对象转化成一个字符串，一般用于print方法'''
print("重写__str__方法")
return "名字是：{0},年龄是 {1}".format(self.name,self.__age)
p = Person("王尚",18)
print(p)
s = str(p)多重继承
Python支持多重继承，一个子类可以有多个“直接父类”。这样，就具备了“多个父类”的特点。但是由于，这样会被“类的整体层次”搞的异常复杂，尽量避免使用。
class A:
def aa(self):
print("aa")
class B:
def bb(self):
print("bb")
class C(B,A):
def cc(self):
print("cc")
c = C()
c.cc()
c.bb()
c.aa()类结构为：
MRO方法解析顺序
Python支持多继承，如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将“从左向右”按顺序搜索。
MRO（Method Resolution Order）：方法解析顺序。 我们可以通 过 mro() 方法获得“类的层次结构”，方法解析顺序也是按照这个“类的 层次结构”寻找的。
class A:
def aa(self):
print("aa")
def say(self):
print("say AAA!")
class B:
def bb(self):
print("bb")
def say(self):
print("say BBB!")
class C(B,A):
def cc(self):
print("cc")
c = C()
print(C.mro()) #打印类的层次结构
c.say() #解释器寻找方法是“从左到右”的方式寻找，此时会执行B类中的say()执行结果：
[, , , ]
say BBB! super()获得父类定义
在子类中，如果想要获得父类的方法时，我们可以通过 super() 来做。 super() 代表父类的定义，不是父类对象。
❤️想调用父类的构造方法： super(子类名称,self).__init__(参数列表)
class A:
def __init__(self):
print("A的构造方法")
def say(self):
print("A: ",self)
print("say AAA")
class B(A):
def __init__(self):
super(B,self).__init__() #调用父类的构造方法
print("B的构造方法")
def say(self):
#A.say(self) 调用父类的say方法
super().say() #通过super()调用父类的方法
print("say BBB")
b = B()
b.say()运行结果：
A: <__main__.B object at 0x007A5690>
say AAA
say BBB多态
多态（polymorphism）是指同一个方法调用由于对象不同可能会产生不同的行为。
比如：现实生活中，同一个方法，具体实现会完全不同。 比 如：同样是调用人“吃饭”的方法，中国人用筷子吃饭，英国人用 刀叉吃饭，印度人用手吃饭。
关于多态要注意以下2点：
1 、多态是方法的多态，属性没有多态。
2、 多态的存在有2个必要条件：继承、方法重写
#多态
class Animal:
def shout(self):
print("动物叫了一声")
class Dog(Animal):
def shout(self):
print("小狗，汪汪汪")
class Cat(Animal):
def shout(self):
print("小猫，喵喵喵")
def animalShout(a):
a.shout() #传入的对象不同，shout方法对应的实际行为也不同。
animalShout(Dog())
animalShout(Cat())特殊方法和运算符重载
Python的运算符实际上是通过调用对象的特殊方法实现的。
a = 20
b = 30
c = a+b
d = a.__add__(b)
print("c=",c)
print("d=",d)运算结果：
c= 50
d= 50常见的特殊方法统计如下：
每个运算符实际上都对应了相应的方法，统计如下：
我们可以重写上面的特殊方法，即实现了“运算符的重载”。
#测试运算符的重载
class Person:
def __init__(self,name):
self.name = name
def __add__(self, other):
if isinstance(other,Person):
return "{0}--{1}".format(self.name,other.name)
else:
return "不是同类对象，不能相加"
def __mul__(self, other):
if isinstance(other,int):
return self.name*other
else:
return "不是同类对象，不能相乘"
p1 = Person("王尚")
p2 = Person("王希希")
x = p1 + p2
print(x)
print(p1*3)运算结果：
王尚--王希希
王尚王尚王尚
特殊属性
Python对象中包含了很多双下划线开始和结束的属性，这些是特殊属性，有特殊用法。这里我们列出常见的特殊属性：
#测试特殊属性
class A:
pass
class B:
pass
class C(B,A):
def __init__(self,nn):
self.nn = nn
def cc(self):
print("cc")
c = C(3)
print(c.__dict__)
print(c.__class__)
print(C.__bases__)
print(C.mro())
print(A.__subclasses__())运行结果：
['__class__', '__delattr__', '__dict__',
'__dir__', '__doc__', '__eq__', '__format__',
'__ge__', '__getattribute__', '__gt__',
'__hash__', '__init__', '__init_subclass__',
'__le__', '__lt__', '__module__', '__ne__',
'__new__', '__reduce__', '__reduce_ex__',
'__repr__', '__setattr__', '__sizeof__',
'__str__', '__subclasshook__', '__weakref__','cc', 'nn']
{'nn': 3}
(, )
[, ,
, ]
[] 对象的浅拷贝和深拷贝
浅拷贝
Python拷贝一般都是浅拷贝。
浅拷贝：拷贝时，拷贝源对象，但对象包含的子对象内容不拷贝。
深拷贝
使用 copy 模块的 deepcopy 函数，递归拷贝对象中包含的子对象。
深拷贝：拷贝时，拷贝源对象，也递归拷贝对象中包含的子对象
#测试对象的引用赋值、浅拷贝、深拷贝
import copy
class MobilePhone:
def __init__(self,cpu):
self.cpu = cpu
class CPU:
pass
c = CPU()
m = MobilePhone(c)
print("----浅拷贝-------")
m2 = copy.copy(m) #m2是新拷贝的另一个手机对象
print("m：",id(m))
print("m2：",id(m2))
print("m的cpu：",id(m.cpu))
print("m2的cpu：",id(m2.cpu)) #m2和m拥有了一样的cpu对象
print("----深拷贝--------")
m3 = copy.deepcopy(m)
print("m：",id(m))
print("m3：",id(m3))
print("m的cpu：",id(m.cpu))
print("m3的cpu：",id(m3.cpu)) #m3和m拥有不一样的cpu对象运算结果：
----浅拷贝-------
m： 1879267229360
m2： 1879267228592
m的cpu： 1879267229648
m2的cpu： 1879267229648
----深拷贝--------
m： 1879267229360
m3： 1879267222256
m的cpu： 1879267229648
m3的cpu： 1879267221968