Python基础知识总结3-面向对象进阶知识

一个双鱼座的测开

已于 2024-01-06 18:53:05 修改

阅读量825

点赞数 19

分类专栏： Python 文章标签： python java 开发语言

于 2024-01-06 17:46:49 首次发布

伟仔

本文链接：https://blog.csdn.net/weixin_42439274/article/details/135426523

版权

Python 专栏收录该内容

27 篇文章 1 订阅

订阅专栏

Python是面向对象的语言，支持面向对象编程的三大特性：继承、
封装（隐藏）、多态。

封装（隐藏）

隐藏对象的属性和实现细节，只对外提供必要的方法。相当于将“细节封装起来”，只对外暴露“相关调用方法”。
通过前面学习的“私有属性、私有方法”的方式，实现“封装”。 Python追求简洁的语法，没有严格的语法级别的“访问控制
符”，更多的是依靠程序员自觉实现。

继承

继承可以让子类具有父类的特性，提高了代码的重用性。从设计上是一种增量进化，原有父类设计不变的情况下，可以增加新的功能，或者改进已有的算法。

多态

多态是指同一个方法调用由于对象不同会产生不同的行为。生活中这样的例子比比皆是：同样是休息方法，人不同休息方法
不同。张三休息是睡觉，李四休息是玩游戏，程序员休息是“敲几行代码”。

继承

在这里插入图片描述

子类扩展父类

继承是面向对象编程的三大特征之一。继承让我们更加容易实现类
的扩展。实现代码的重用，不用再重新发明轮子(don’t reinvent
wheels)。
如果一个新类继承自一个设计好的类，就直接具备了已有类的特
征，就大大降低了工作难度。已有的类，我们称为“父类或者基
类”，新的类，我们称为“子类或者派生类”。

在这里插入图片描述

语法格式

Python支持多重继承，一个子类可以继承多个父类。继承的语法格
式如下：

class  子类类名(父类1[，父类2，...])：
	类体

如果在类定义中没有指定父类，则默认父类是 object类。也就是说， object 是所有类的父类，里面定义了一些所有类共有的默认
实现，比如： new()

关于构造函数：

1 子类不重写 init ，实例化子类时，会自动调用父类定义的 init 。
2 子类重写了 init 时，实例化子类，就不会调用父类已经定义的 init
3 如果重写了 init 时，要使用父类的构造方法，可以使用 super 关键字，也可以使用如下格式调用：
父类名.init(self, 参数列表)

class Person:
    def __init__(self,name,age):
        print("Person的构造方法")
        self.name = name
        self.age = age

    def say_age(self):
        print(self.name,"的年龄是：",self.age)


 class Student(Person):

    def __init__(self,name,age,score):
        # 子类并不会自动调用父类的__init__()，我们必须显式的调用它。
        # Person.__init__(self, name, age)
        #
        
		super(Student,self).__init__(name,age)
        print("Student的构造方法")
        # self.name = name
        # self.age = age
        self.score = score

# 调用
s1 = Student("张三",15,85)
#s1.say_age()
print(dir(s1))

类成员的继承和重写

1 成员继承：子类继承了父类除构造方法之外的所有成员。
⚠️(私有属性、私有方法也被继承)
2 方法重写：子类可以重新定义父类中的方法，这样就会覆盖父类
的方法，也称为“重写”

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def say_age(self):
        print(self.name,"的年龄是：",self.age)

    def say_name(self):
       print("我是",self.name)


 class Student(Person):

    def __init__(self,name,age,score):
        Person.__init__(self,name,age)  
        self.score = score

    def say_score(self):
        print(self.name,"的分数是：",self.score)

    def say_name(self):      #重写父类的方法
        print("报告老师，我是",self.name)

 s1 = Student("张三",15,85)
 s1.say_score()
 s1.say_name()
 s1.say_age()

张三的分数是： 85
报告老师，我是张三
张三的年龄是： 15

查看类的继承层次结构

通过类的方法 mro() 或者类的属性 _ _mro_ _ 可以输出这个类的继承层次
结构。

class A:pass
class B(A):pass
class C(B):pass
print(C.mro())

[<class ‘main.C’>, <class ‘main.B’>,
<class ‘main.A’>, <class ‘object’>]

object根类

object 类是所有类的父类，因此所有的类都有 object 类的属性和方法。

dir() 查看对象属性

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__ __eakref__ age name say_age
2 object 的所有属性， Person 类作为 object 的子类，显然包含了所有的
属性
3 我们打印 age 、 name 、 say_age ，发现 say_age 虽然是方法，实际上也
是属性。只不过，这个属性的类型是 method 而已。

重写 str() 方法

object 有一个 _ _str_\ _() 方法，用于返回一个对于“对象的描述”。内置函数 str(对象) ,调用的就是
_ _str_\ _()

_ _str_\ _() 经常用于 print() 方法，帮助我们查看对象的信息。_ _str_\ _() 可以重写

多重继承

在这里插入图片描述
Python支持多重继承，一个子类可以有多个“直接父类”。这样，就
具备了“多个父类”的特点。但是由于，这样会被“类的整体层次”搞的
异常复杂，尽量避免使用。

1 class A:
2    def aa(self):
3        print("aa")
4
5 class B:
6    def bb(self):
7        print("bb")
8
9 class C(B,A):
10    def cc(self):
11        print("cc")
12
13 c = C()
14 c.cc()
15 c.bb()
16 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__() #调用父类的构造方法
        # super().__init__(self) 
        print("B的构造方法")
    def say(self):
        #A.say(self)   调用父类的say方法
        super().say()   #通过super()调用父类的方法
        print("say BBB")

 b = B()
 b.say()

1 A: <main.B object at 0x007A5690>
2 say AAA
3 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__())

1 [‘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’]
2 {‘nn’: 3}
3 <class’main.C’>
4 (<class ‘main.B’>, <class ‘main.A’>)
5 [<class’main.C’>, <class ‘main.B’>, <class ‘main.A’>, <class
‘object’>]
6 [<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

组合

在这里插入图片描述
两人组合后，可以复用对方的属性和方法！

#组合测试
class MobilePhone:
    def __init__(self,cpu,screen):
        self.cpu = cpu
        self.screen = screen
class CPU:
    def calculate(self):
        print("计算，算个12345")
class Screen:
    def show(self):
        print("显示一个好看的画面")
 
c = CPU()
s = Screen()
m = MobilePhone(c,s)
m.cpu.calculate()       #通过组合，我们也能调用cpu对象的方法。相当于手机对象间接拥有了“cpu的方法”

_ init _ 构造方法和 _ new _ 方法

初始化对象，我们需要定义构造函数 init() 方法。构造方法用于执
行“实例对象的初始化工作”，即对象创建后，初始化当前对象的相
关属性，无返回值。

__init__ 的要点如下：
名称固定，必须为： __init__
第一个参数固定，必须为： self 。 self 指的就是刚刚创建好的实
例对象
构造函数通常用来初始化实例对象的实例属性，如下代码就是初
始化实例属性： name 和 score
通过“类名(参数列表)”来调用构造函数。调用后，将创建好的对
象返回给相应的变量。比如： s1 = Student(‘张三’, 80)

__init__ 方法：初始化创建好的对象，初始化指的是：“给实例属
性赋值”

__new__ 方法: 用于创建对象，但我们一般无需重定义该方法
如果我们不定义 init 方法，系统会提供一个默认的 init 方法。
如果我们定义了带参的 init 方法，系统不创建默认的 init 方法

实例属性和实例方法

实例属性

实例属性是从属于实例对象的属性，也称为“实例变量”。他的使用
有如下几个要点：

1 实例属性一般在 init() 方法中通过如下代码定义： self.实例属性名 = 初始值

2 在本类的其他实例方法中，也是通过 self 进行访问： self.实例属性名

3 创建实例对象后，通过实例对象访问： obj01 = 类名() #创建和初始化对象，调用 init() 初始化属性
obj01.实例属性名 = 值 #可以给已有属性赋值，也可以新加属性

class Student:
    def __init__(self,name,score):
        self.name = name #增加name属性
        self.score = score #增加score属性
    def say_score(self):
        self.age = 18     #增加age属性
        print("{0}的分数是{1}".format(self.name,self.score))
        
s1 = Student("张三",80)
s1.say_score()
print(s1.age)
s1.salary = 3000 #s1对象增加salary属性
s2 = Student("李四",90)
s2.say_score()
print(s2.age)

实例方法

实例方法是从属于实例对象的方法。实例方法的定义格式如下：

def  方法名(self [, 形参列表])：
 	函数体

方法的调用格式如下：
对象.方法名([实参列表])

要点：
1 定义实例方法时，第一个参数必须为 self 。和前面一样， self 指当前的实例对象。
2 调用实例方法时，不需要也不能给self 传参。 self 由解释器自动传参

函数和方法的区别

1 都是用来完成一个功能的语句块，本质一样。
2 方法调用时，通过对象来调用。方法从属于特定实例对象，普通函数没有这个特点
3 直观上看，方法定义时需要传递self，函数不需要

实例对象的方法调用本质

在这里插入图片描述

其他操作

dir(obj) 可以获得对象的所有属性、方法
obj._ _dict_ _ 对象的属性字典
pass 空语句
isinstance（对象,类型）判断“对象”是不是“指定类型”

类对象、类属性、类方法、静态方法

类对象

我们在前面讲的类定义格式中， class 类名：。实际上，当解释器执行
class 语句时，就会创建一个类对象。

类属性

类属性是从属于“类对象”的属性，也称为“类变量”。由于，类属性从
属于类对象，可以被所有实例对象共享。
类属性的定义方式：

class  类名：
 	类变量名= 初始值

del方法 (析构函数)和垃圾回收机制

_ del _() 称为“析构方法”，用于实现对象被销毁时所需的操作。比如：
释放对象占用的资源，例如：打开的文件资源、网络连接等。
Python实现自动的垃圾回收，当对象没有被引用时（引用计数为
0），由垃圾回收器调用 _ del _() 。
我们也可以通过 del语句删除对象，从而保证调用 _ del _() 。
系统会自动提供 _ del _方法，一般不需要自定义析构方法。

1 #析构函数
2 class Person:
3
4    def __del__(self):
5        print("销毁对象：{0}".format(self))
6
7 p1 = Person()
8 p2 = Person()
9 del p2
10 print("程序结束")

call 方法和可调用对象

1 Python 中，凡是可以将 () 直接应用到自身并执行，都称为可调
用对象。
2 可调用对象包括自定义的函数、Python 内置函数、以及本节所
讲的实例对象。
3 定义了 call() 的对象，称为“可调用对象”，即该对象可以像函数
一样被调用。
4 该方法使得实例对象可以像调用普通函数那样，以“对象名()”的
形式使用。

1 def f1():
2    print("f1")
3
4 f1()   #本质也是调用了__call__()方法
5
6 class Car:
7    def __call__(self, age,money):
8        print("__call__方法")
9        print("车龄：{0},金额：{1}".format(age,money))
10
11 f2 = Car()
12 f2(3,200000)    #像调用函数那样调用，本质也是调用了__call__()

f1
车龄：3,金额：200000

方法没有重载

如果我们在类体中定义了多个重名的方法，只有最后一个方法有效。
建议：不要使用重名的方法！Python中方法没有重载。

在其他一些语言(比如：Java)中，可以定义多个重名的方法，只要保证方法签名唯一即可。方
法签名包含3个部分：方法名、参数数量、参数类型。
Python中，方法的的参数没有声明类型（调用时确定参数的类型），参数的数量也可以由可
变参数控制。因此，Python中是没有方法的重载的。

方法的动态性

在这里插入图片描述

Python是动态语言，我们可以动态的为类添加新的方法，或者动态
的修改类的已有的方法

#测试方法的动态性
#测试方法的动态性
class Person:
    def work(self):
        print("努力上班！")
def play_game(self):
    print("玩游戏")
def work2(s):
    print("好好工作，努力上班！")
Person.play = play_game
Person.work = work2
p = Person()
p.play()
p.work()

我们可以看到， Person 动态的新增了 play_game 方法，以及用 work2 替换
了 work 方法

私有属性和私有方法(实现封装)

在这里插入图片描述
Python对于类的成员没有严格的访问控制限制，这与其他面向对象
语言有区别。关于私有属性和私有方法，有如下要点：
1 通常我们约定，两个下划线开头的属性是私有的(private)。其他为公共的(public)。
2 类内部可以访问私有属性(方法)
3 类外部不能直接访问私有属性(方法)
4 类外部可以通过 _类名__私有属性(方法)名 ”访问私有属性(方法)

@property 装饰器

@property 可以将一个方法的调用方式变成“属性调用”。
@property 主要用于帮助我们处理属性的读操作、写操作。对于某一个
属性，我们可以直接通过：
emp1.salary = 30000
如上的操作读操作、写操作。但是，这种做法不安全。比如，我需
要限制薪水必须为 1-10000 的数字。这时候，我们就需要通过使用装
饰器 @property 来处理。

@property
def 方法名(self)
    代码块

class Rect:
    def __init__(self,area):
        self.__area = area
    @property
    def area(self):
        return self.__area
rect = Rect(30)
#直接通过方法名来访问 area 方法
print("矩形的面积是：",rect.area)

而要想实现修改 area 属性的值，还需要为 area 属性添加 setter 方法，就需要用到 setter 装饰器，它的语法格式如下：

@方法名.setter
def 方法名(self, value):
    代码块

#测试@property
class Employee:

    def __init__(self,name,salary):
        self.name = name
        self.__salary = salary

    @property               #相当于salary属性的getter方法
    def salary(self):
        print("月薪为{0},年薪为{1}".format(self.__salary,*self.__salary)))
        return self.__salary;

    @salary.setter
    def salary(self,salary):    #相当于salary属性的setter方法
        if(0<salary<1000000):
            self.__salary = salary
        else:
            print("薪水录入错误！只能在0-1000000之间")


 emp1 = Employee("高淇",100)
 print(emp1.salary)

 emp1.salary = -200

这样，area 属性就有了 getter 和 setter 方法，该属性就变成了具有读写功能的属性。

除此之外，还可以使用 deleter 装饰器来删除指定属性，其语法格式为：

@方法名.deleter
def 方法名(self):
    代码块

@area.deleter
def area(self):
    self.__area = 0

del rect.area
print("删除后的area值为：",rect.area)

属性和方法命名总结

_xxx ：保护成员，不能用 from module import * 导入，只有类对象和子类对象能访问这些成员。

_ _xxx_ _ ：系统定义的特殊成员
_ _xxx ：类中的私有成员，只有类对象自己能访问，子类对象也不能访问。（但，在类外部可以通
过对象名. _类名__xxx 这种特殊方式访问。Python不存在严格意义的私有成员）

一个双鱼座的测开

关注

19
点赞
踩
15

收藏

觉得还不错? 一键收藏
打赏
0
评论
Python基础知识总结3-面向对象进阶知识

在子类中，如果想要获得父类的方法时，我们可以通过 super() 来做。super() 代表父类的定义，不是父类对象。❤️想调用父类的构造方法：super(子类名称,self).init(参数列表)class A:print("A的构造方法")super(B,self).__init__() #调用父类的构造方法print("B的构造方法")#A.say(self) 调用父类的say方法super().say() #通过super()调用父类的方法b = B()b.say()
复制链接

扫一扫