Python入门【object根类、重写 __str__() 方法 、多重继承、MRO方法解析顺序、 super()获得父类定义、多态、特殊方法和运算符重载、特殊属性】(十六)

作者简介:大家好,我是爱敲代码的小王,CSDN博客博主,Python小白
系列专栏:python入门到实战、Python爬虫开发、Python办公自动化、Python数据分析、Python前后端开发
如果文章知识点有错误的地方,请指正!和大家一起学习,一起进步
如果感觉博主的文章还不错的话,请三连支持一下博主哦
博主正在努力完成2023计划中:以梦为马,扬帆起航,2023追梦人

python入门到实战专栏:从入门到实战
Python爬虫开发专栏:从入门到实战
 Python办公自动化专栏:从入门到实战
Python数据分析专栏:从入门到实战
Python前后端开发专栏:从入门到实战    

目录

object根类

重写 __str__() 方法 

多重继承

MRO方法解析顺序 

super()获得父类定义

多态

特殊方法和运算符重载

特殊属性 

对象的浅拷贝和深拷贝


 

object根类

Python入门【object根类、重写 __str__() 方法 、多重继承、MRO方法解析顺序、 super()获得父类定义、多态、特殊方法和运算符重载、特殊属性】(十六)_第1张图片

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入门【object根类、重写 __str__() 方法 、多重继承、MRO方法解析顺序、 super()获得父类定义、多态、特殊方法和运算符重载、特殊属性】(十六)_第2张图片

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

类结构为:

Python入门【object根类、重写 __str__() 方法 、多重继承、MRO方法解析顺序、 super()获得父类定义、多态、特殊方法和运算符重载、特殊属性】(十六)_第3张图片

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

多态

Python入门【object根类、重写 __str__() 方法 、多重继承、MRO方法解析顺序、 super()获得父类定义、多态、特殊方法和运算符重载、特殊属性】(十六)_第4张图片

多态(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

常见的特殊方法统计如下:

Python入门【object根类、重写 __str__() 方法 、多重继承、MRO方法解析顺序、 super()获得父类定义、多态、特殊方法和运算符重载、特殊属性】(十六)_第5张图片

每个运算符实际上都对应了相应的方法,统计如下:

Python入门【object根类、重写 __str__() 方法 、多重继承、MRO方法解析顺序、 super()获得父类定义、多态、特殊方法和运算符重载、特殊属性】(十六)_第6张图片 

我们可以重写上面的特殊方法,即实现了“运算符的重载”。

#测试运算符的重载
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对象中包含了很多双下划线开始和结束的属性,这些是特殊属性,有特殊用法。这里我们列出常见的特殊属性:

Python入门【object根类、重写 __str__() 方法 、多重继承、MRO方法解析顺序、 super()获得父类定义、多态、特殊方法和运算符重载、特殊属性】(十六)_第7张图片

#测试特殊属性
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入门【object根类、重写 __str__() 方法 、多重继承、MRO方法解析顺序、 super()获得父类定义、多态、特殊方法和运算符重载、特殊属性】(十六)_第8张图片

浅拷贝

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

你可能感兴趣的:(python入门到实战,python,数据结构,数据分析)