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

艾派徳

已于 2023-08-19 21:42:00 修改

阅读量364

点赞数 8

分类专栏： python入门到实战文章标签： python 数据结构数据分析

于 2023-08-02 21:19:42 首次发布

本文链接：https://blog.csdn.net/abc19991119/article/details/132071458

版权

python入门到实战专栏收录该内容

35 篇文章 19 订阅

订阅专栏

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

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

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 <class 'int'>
name <class 'str'>
say_age <class 'method'>

⚠️关于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()

执行结果：

[<class 'main.C'>, <class 'main.B'>, <class 'main.A'>, <class
'object'>]
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}
<class '__main__.C'>
(<class '__main__.B'>, <class '__main__.A'>)
[<class '__main__.C'>, <class '__main__.B'>,
<class '__main__.A'>, <class 'object'>]
[<class '__main__.C'>]

对象的浅拷贝和深拷贝

浅拷贝

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

艾派徳

关注

8
点赞
踩
10

收藏

觉得还不错? 一键收藏
8
评论
Python入门【object根类、重写 __str__() 方法、多重继承、MRO方法解析顺序、 super()获得父类定义、多态、特殊方法和运算符重载、特殊属性】(十六)

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

扫一扫